From 89b8900fb2ae0aa141717cefa4667587fd179def Mon Sep 17 00:00:00 2001 From: StefanMoCoAt Date: Mon, 26 May 2025 23:00:15 +0200 Subject: [PATCH] impl div Klassen --- .../Domänen-Stammdaten_26-Mai-25.puml | 283 +++++++++ .../kotlin/at/mocode/shared/enums/Enums.kt | 31 +- .../at/mocode/shared/model/Abteilung.kt | 4 +- .../kotlin/at/mocode/shared/model/Bewerb.kt | 4 +- .../kotlin/at/mocode/shared/model/Platz.kt | 4 +- .../kotlin/at/mocode/shared/model/Turnier.kt | 2 +- .../at/mocode/shared/model/Veranstaltung.kt | 4 +- .../mocode/shared/model/domaene/DomLizenz.kt | 55 ++ .../model/domaene/{verein => }/DomPerson.kt | 4 +- .../model/domaene/{verein => }/DomPferd.kt | 0 .../shared/model/domaene/DomQualifikation.kt | 56 ++ .../model/domaene/{verein => }/DomVerein.kt | 2 +- .../shared/model/veranstaltung/Platz.kt | 48 ++ .../model/veranstaltung/Pruefung_Abteilung.kt | 130 ++++ .../model/veranstaltung/Pruefung_OEPS.kt | 92 +++ .../model/veranstaltung/Turnier_OEPS.kt | 125 ++++ .../model/veranstaltung/Turnier_hat_Platz.kt | 26 + .../veranstaltung/VeranstaltungsRahmen.kt | 82 +++ .../veranstaltung/cup/MCS_Wertungspruefung.kt | 41 ++ .../cup/Meisterschaft_Cup_Serie.kt | 73 +++ .../spezifika/DressurPruefungSpezifika.kt | 69 +++ .../spezifika/SpringPruefungSpezifika.kt | 83 +++ .../at/mocode/shared/stammdaten/Person.kt | 4 +- .../mocode/shared/entitaeten/ArtikelTest.kt | 152 ----- .../entitaeten/MeisterschaftReferenzTest.kt | 165 ----- .../at/mocode/shared/entitaeten/PlatzTest.kt | 141 ----- .../mocode/shared/entitaeten/TurnierTest.kt | 440 -------------- .../shared/entitaeten/VeranstaltungTest.kt | 335 ---------- .../at/mocode/shared/enums/EnumsTest.kt | 573 ------------------ .../shared/serializers/SerializationTest.kt | 229 ------- .../shared/stammdaten/LizenzInfoTest.kt | 166 ----- .../at/mocode/shared/stammdaten/PersonTest.kt | 386 ------------ .../at/mocode/shared/stammdaten/PferdTest.kt | 311 ---------- .../at/mocode/shared/stammdaten/VereinTest.kt | 225 ------- 34 files changed, 1199 insertions(+), 3146 deletions(-) create mode 100644 docs/diagrams/Domänen-Stammdaten_26-Mai-25.puml create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomLizenz.kt rename shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/{verein => }/DomPerson.kt (97%) rename shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/{verein => }/DomPferd.kt (100%) create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomQualifikation.kt rename shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/{verein => }/DomVerein.kt (98%) create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Platz.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_Abteilung.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_OEPS.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_OEPS.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_hat_Platz.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/VeranstaltungsRahmen.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/MCS_Wertungspruefung.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/Meisterschaft_Cup_Serie.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/DressurPruefungSpezifika.kt create mode 100644 shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/SpringPruefungSpezifika.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/enums/EnumsTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/serializers/SerializationTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/LizenzInfoTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PersonTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PferdTest.kt delete mode 100644 shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/VereinTest.kt diff --git a/docs/diagrams/Domänen-Stammdaten_26-Mai-25.puml b/docs/diagrams/Domänen-Stammdaten_26-Mai-25.puml new file mode 100644 index 00000000..ca80df65 --- /dev/null +++ b/docs/diagrams/Domänen-Stammdaten_26-Mai-25.puml @@ -0,0 +1,283 @@ +@startuml +!theme vibrant + +title Datenbankmodell ÖTO - Fokus: Domänen-Stammdaten (Stand: 26. Mai 2025, 20:12 Uhr) + +' Diagramm-Optionen +skinparam linetype ortho +hide empty members +skinparam shadowing false +skinparam defaultFontName "Segoe UI" +skinparam defaultFontSize 9 +skinparam roundCorner 10 +allow_mixing +skinparam packageStyle rect + +' --- Enums (mit Suffix E) - Auswahl --- +enum DatenQuelleE { + OEPS_ZNS, + MANUELL_NATIONAL, + MANUELL_INTERNATIONAL, + SYSTEM_GENERIERTR + } +enum GeschlechtE { + M, + W, + UNBEKANNT + } + ' Angepasst gemäß deiner Implementierung +enum PferdeGeschlechtE { + HENGST, + STUTE, + WALLACH, + UNBEKANNT + } +enum SparteE { + DRESSUR, + SPRINGEN, + VIELSEITIGKEIT, + } + + +' ##################################################################### +' ### Service OeTO-Verwaltung (Definitionen) - Gekürzt dargestellt ### +' ##################################################################### +package "Service OeTO-Verwaltung" { + entity LizenzTypGlobal { + + lizenzTypGlobalId : UUID <> + -- + lizenzTypGlobalCode : VARCHAR(15) <> ' Eindeutiges OEPS Kürzel + bezeichnung : VARCHAR(100) + spartePrimaer : SparteE? + kategorieLizenzText : VARCHAR(50) ' LizenzKategorieE als String oder Enum intern + stufe: VARCHAR(10)? + aufschluesselungKombilizenzCodes: List? + istAktiv: Boolean + } + + entity QualifikationsTyp { + + qualTypId : UUID <> + -- + qualTypCode : VARCHAR(30) <> ' Eindeutiges Kürzel + bezeichnung : VARCHAR(100) + sparte : SparteE + istAktiv: Boolean + } + + entity LandDefinition { + + landId: UUID <> + -- + isoAlpha2Code: String <> + isoAlpha3Code: String <> + nameDeutsch: String + } + + entity BundeslandDefinition { + + bundeslandId: UUID <> + -- + landId: UUID <> + oepsCode: String? ' Eindeutig für Österreich + name: String + } +} + +' ##################################################################### +' ### Service ZNS-Daten (Staging) - Gekürzt dargestellt ### +' ##################################################################### +package "Service ZNS-Daten (Staging)" { + entity Person_ZNS_Staging { + + oeps_satz_nr_person : VARCHAR(6) <> + -- + familienname_roh : VARCHAR(50) + vorname_roh : VARCHAR(25) + '.. viele weitere Rohdaten-Felder .. + lizenzinfo_raw_oeps_roh : VARCHAR(10)? + qualifikationen_raw_oeps_roh: VARCHAR(30)? + import_timestamp: TIMESTAMP + } + entity Pferd_ZNS_Staging { + + oeps_satz_nr_pferd : VARCHAR(10) <> + '.. viele weitere Rohdaten-Felder .. + import_timestamp: TIMESTAMP + } + entity Verein_ZNS_Staging { + + oeps_vereins_nr : VARCHAR(4) <> + name_roh : VARCHAR(50) + import_timestamp: TIMESTAMP + } +} + +' #################################################################################### +' ### Service Domänen-Stammdaten (Unsere finalisierten Domänenobjekte) ### +' #################################################################################### +package "Service Domänen-Stammdaten" { + entity DomVerein { + + vereinId: UUID <> + -- + oepsVereinsNr: String? <> + name: String + kuerzel: String? + adresseStrasse: String? + plz: String? + ort: String? + bundeslandId: UUID <>? + landId: UUID <> + emailAllgemein: String? + telefonAllgemein: String? + webseiteUrl: String? + datenQuelle: DatenQuelleE + istAktiv: Boolean + notizenIntern: String? + createdAt: Instant + updatedAt: Instant + } + + entity DomPerson { + + personId: UUID <> + -- + oepsSatzNr: String? <> + nachname: String + vorname: String + titel: String? + geburtsdatum: LocalDate? + geschlecht: GeschlechtE? + nationalitaetLandId: UUID <>? + feiId: String? + telefon: String? + email: String? + strasse: String? + plz: String? + ort: String? + adresszusatzZusatzinfo: String? + stammVereinId: UUID <>? + mitgliedsNummerBeiStammVerein: String? + istGesperrt: Boolean + sperrGrund: String? + altersklasseOepsCodeRaw: String? + istJungerReiterOepsFlag: Boolean + kaderStatusOepsRaw: String? + datenQuelle: DatenQuelleE + istAktiv: Boolean + notizenIntern: String? + createdAt: Instant + updatedAt: Instant + } + + entity DomPferd { + + pferdId: UUID <> + -- + oepsSatzNrPferd: String? <> + oepsKopfNr: String? + name: String + lebensnummer: String? + feiPassNr: String? + geburtsjahr: Int? + geschlecht: PferdeGeschlechtE? + farbe: String? + rasse: String? + abstammungVaterName: String? + abstammungMutterName: String? + abstammungMutterVaterName: String? + abstammungZusatzInfo: String? + besitzerPersonId: UUID <>? + verantwortlichePersonId: UUID <>? + heimatVereinId: UUID <>? + letzteZahlungPferdegebuehrJahrOeps: Int? + stockmassCm: Int? + datenQuelle: DatenQuelleE + istAktiv: Boolean + notizenIntern: String? + createdAt: Instant + updatedAt: Instant + } + + entity DomLizenz { + + lizenzId: UUID <> + -- + personId: UUID <> + lizenzTypGlobalId: UUID <> ' Verweis auf Service_OeTO_Verwaltung.LizenzTypGlobal + gueltigBisJahr: Int? + ausgestelltAm: LocalDate? + istAktivBezahltOeps: Boolean + notiz: String? + createdAt: Instant + updatedAt: Instant + } + + entity DomQualifikation { + + qualifikationId: UUID <> + -- + personId: UUID <> + qualTypId: UUID <> ' Verweis auf Service_OeTO_Verwaltung.QualifikationsTyp + bemerkung: String? + gueltigVon: LocalDate? + gueltigBis: LocalDate? + istAktiv: Boolean + createdAt: Instant + updatedAt: Instant + } +} + +' --- Beziehungen für Domänen-Stammdaten --- +Service_Domänen_Stammdaten.DomVerein -- "? Service_OeTO_Verwaltung.BundeslandDefinition : hat Bundesland" +Service_Domänen_Stammdaten.DomVerein -- "1" Service_OeTO_Verwaltung.LandDefinition : ist in Land" + +Service_Domänen_Stammdaten.DomPerson -- "? Service_OeTO_Verwaltung.LandDefinition : hat Nationalität" +Service_Domänen_Stammdaten.DomPerson "0..1" -- "1" Service_Domänen_Stammdaten.DomVerein : hat Stammverein > +Service_Domänen_Stammdaten.DomPerson "1" -- "0..*" Service_Domänen_Stammdaten.DomLizenz : besitzt +Service_Domänen_Stammdaten.DomPerson "1" -- "0..*" Service_Domänen_Stammdaten.DomQualifikation : besitzt + +Service_Domänen_Stammdaten.DomPferd "0..1" -- "1" Service_Domänen_Stammdaten.DomPerson : hat Besitzer > +Service_Domänen_Stammdaten.DomPferd "0..1" -- "1" Service_Domänen_Stammdaten.DomPerson : hat Verantwortlichen > +Service_Domänen_Stammdaten.DomPferd "0..1" -- "1" Service_Domänen_Stammdaten.DomVerein : hat Heimatverein > + +Service_Domänen_Stammdaten.DomLizenz -- "1" Service_OeTO_Verwaltung.LizenzTypGlobal : ist vom Typ +Service_Domänen_Stammdaten.DomQualifikation -- "1" Service_OeTO_Verwaltung.QualifikationsTyp : ist vom Typ + + +' --- Andeutung der weiteren Pakete und wichtigsten Entitäten (stark gekürzt) --- +package "Service Veranstaltungsplanung" { + entity VeranstaltungsRahmen + entity Turnier_OEPS + 'BewerbBasis' + entity Pruefung_OEPS + package "Sportfachliche Details Pruefung" { + entity DressurPruefungSpezifika + entity SpringPruefungSpezifika + } + entity Pruefung_Abteilung + entity Meisterschaft_Cup_Serie +} + +package "Service Nennungsabwicklung" { + entity Nennung + entity NennungsTeilnehmerSnapshot + entity Startfolge + entity Ergebnis_Zeile + package "Sportfachliche Details Ergebnis" { + entity DressurErgebnisSpezifika + entity SpringenErgebnisSpezifika + } +} + +package "Service Funktionärsplanung" { + entity FunktionaerEinsatzPlanung +} + + +' --- Wichtige übergreifende Beziehungen (Beispiele) --- +Service_Veranstaltungsplanung.VeranstaltungsRahmen "1" -- "0..*" Service_Veranstaltungsplanung.Turnier_OEPS +Service_Veranstaltungsplanung.Turnier_OEPS "1" -- "0..*" Service_Veranstaltungsplanung.Pruefung_OEPS +Service_Veranstaltungsplanung.Pruefung_OEPS "1" o-- "0..1" Service_Veranstaltungsplanung.Sportfachliche_Details_Pruefung.DressurPruefungSpezifika +Service_Veranstaltungsplanung.Pruefung_OEPS "1" o-- "0..1" Service_Veranstaltungsplanung.Sportfachliche_Details_Pruefung.SpringPruefungSpezifika +Service_Veranstaltungsplanung.Pruefung_OEPS "1" -- "1..*" Service_Veranstaltungsplanung.Pruefung_Abteilung + +Service_Nennungsabwicklung.Nennung -- Service_Veranstaltungsplanung.Pruefung_Abteilung +Service_Nennungsabwicklung.Nennung -- Service_Domänen_Stammdaten.DomPerson +Service_Nennungsabwicklung.Nennung -- Service_Domänen_Stammdaten.DomPferd + +Service_Funktionärsplanung.FunktionaerEinsatzPlanung -- Service_Domänen_Stammdaten.DomPerson +Service_Funktionärsplanung.FunktionaerEinsatzPlanung -- Service_Veranstaltungsplanung.VeranstaltungsRahmen +' ... usw. + +@enduml diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt b/shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt index 98415ca2..4f7b5875 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/enums/Enums.kt @@ -11,8 +11,15 @@ enum class DatenQuelleE { OEPS_ZNS, MANUELL } @Serializable enum class VerbandE { OEPS, FEI, SONSTIGE } +@Serializable +enum class CupSerieTypE { CUP_SERIE } + + @Serializable enum class LizenzKategorieE { REITERLIZENZ, FAHRERLIZENZ, STARTKARTE } +@Serializable +enum class LizenzTyp { REITER, FAHRER, VOLTIGIERER, WESTERN, WORKING_EQUITATION, POLO, STARTKARTE_ALLG, STARTKARTE_VOLTIGIEREN, STARTKARTE_WESTERN, STARTKARTE_ISLAND, STARTKARTE_FAHREN_JUGEND, STARTKARTE_HORSEBALL, STARTKARTE_POLO, PARAEQUESTRIAN, SONSTIGE } + @Serializable enum class SportfachStammdatenTypE { DRESSURAUFGABE, WERTUNGSVERFAHREN_SPRINGEN, WERTUNGSVERFAHREN_DRESSUR, BEWERBSKLASSE, BEWERBSKATEGORIE_OETO } @@ -24,37 +31,43 @@ enum class PruefungsViereckE { VIERECK_20X40, VIERECK_20X60 } enum class RichtverfahrenModusE { GM, GT } @Serializable -enum class GeschlechtE { M, W } +enum class ArtDesStechensE { EINFACHES_STECHEN } @Serializable enum class PferdeGeschlechtE { HENGST, STUTE, WALLACH, UNBEKANNT } +@Serializable +enum class EventStatusE { IN_PLANUNG, AKTIV, BEENDET } @Serializable -enum class VeranstalterTyp { VEREIN, FIRMA, PRIVATPERSON, SONSTIGE, UNBEKANNT } +enum class NennungsArtE { + ONLINE_PORTAL, EZNS_OEPS, EMAIL, TELEFON, FAX, VOR_ORT +} + @Serializable -enum class PlatzTyp { AUSTRAGUNG, VORBEREITUNG, LONGIEREN, SONSTIGES } +enum class VeranstalterTypE { VEREIN, FIRMA, PRIVATPERSON, SONSTIGE, UNBEKANNT } @Serializable -enum class NennungsArt { OEPS_ZNS, EIGENES_ONLINE, DIREKT_VERANSTALTER_EMAIL, DIREKT_VERANSTALTER_TELEFON, DIREKT_VERANSTALTER_WHATSAPP, SONSTIGE } +enum class PlatzTypE { AUSTRAGUNG, VORBEREITUNG, LONGIEREN, SONSTIGES } + @Serializable enum class SparteE { DRESSUR, SPRINGEN, VIELSEITIGKEIT, FAHREN, VOLTIGIEREN, WESTERN, DISTANZ, ISLAND, PFERDESPORT_SPIEL, BASIS, KOMBINIERT, SONSTIGES } + @Serializable enum class BewerbStatus { GEPLANT, OFFEN_FUER_NENNUNG, GESCHLOSSEN_FUER_NENNUNG, LAEUFT, ABGESCHLOSSEN, ABGESAGT } @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 } +enum class BeginnzeitTypE { 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 } + @Serializable -enum class RichterPosition { BEI_C, BEI_E, BEI_H, BEI_M, BEI_B, VORSITZ, SEITENRICHTER, SONSTIGE } +enum class RichterPositionE { C, E, H, M, B, VORSITZ, SEITENRICHTER, SONSTIGE } @Serializable -enum class Geschlecht { M, W, D, UNBEKANNT } -@Serializable -enum class LizenzTyp { REITER, FAHRER, VOLTIGIERER, WESTERN, WORKING_EQUITATION, POLO, STARTKARTE_ALLG, STARTKARTE_VOLTIGIEREN, STARTKARTE_WESTERN, STARTKARTE_ISLAND, STARTKARTE_FAHREN_JUGEND, STARTKARTE_HORSEBALL, STARTKARTE_POLO, PARAEQUESTRIAN, SONSTIGE } +enum class GeschlechtE { M, W, D, UNBEKANNT } @Serializable enum class GeschlechtPferd { HENGST, STUTE, WALLACH, UNBEKANNT } diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt index b7f1ee6c..2a50c93b 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/Abteilung.kt @@ -1,6 +1,6 @@ package at.mocode.shared.model -import at.mocode.shared.enums.BeginnzeitTyp +import at.mocode.shared.enums.BeginnzeitTypE import at.mocode.shared.serializers.BigDecimalSerializer import at.mocode.shared.serializers.KotlinInstantSerializer import at.mocode.shared.serializers.KotlinLocalTimeSerializer @@ -41,7 +41,7 @@ data class Abteilung( @Serializable(with = UuidSerializer::class) var platzId: Uuid?, // FK zum Austragungsplatz (kann vom Hauptbewerb abweichen) var datum: LocalDate?, - var beginnzeitTyp: BeginnzeitTyp = BeginnzeitTyp.ANSCHLIESSEND, + var beginnzeitTypE: BeginnzeitTypE = BeginnzeitTypE.ANSCHLIESSEND, @Serializable(with = KotlinLocalTimeSerializer::class) var beginnzeitFix: LocalTime? = null, @Serializable(with = UuidSerializer::class) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt index 69c5b46b..baff2701 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/Bewerb.kt @@ -1,6 +1,6 @@ package at.mocode.shared.model -import at.mocode.shared.enums.BeginnzeitTyp +import at.mocode.shared.enums.BeginnzeitTypE import at.mocode.shared.enums.SparteE import at.mocode.shared.serializers.* import com.benasher44.uuid.Uuid @@ -66,7 +66,7 @@ data class Bewerb( var standardPlatzId: Uuid?, // FK zum Default-Austragungsplatz @Serializable(with = KotlinLocalDateSerializer::class) var standardDatum: LocalDate?, - var standardBeginnzeitTyp: BeginnzeitTyp = BeginnzeitTyp.ANSCHLIESSEND, // neuer Enum Wert + var standardBeginnzeitTypE: BeginnzeitTypE = BeginnzeitTypE.ANSCHLIESSEND, // neuer Enum Wert @Serializable(with = KotlinLocalTimeSerializer::class) var standardBeginnzeitFix: LocalTime? = null, @Serializable(with = UuidSerializer::class) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt index 78f4275b..d156c209 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/Platz.kt @@ -1,6 +1,6 @@ package at.mocode.shared.model -import at.mocode.shared.enums.PlatzTyp +import at.mocode.shared.enums.PlatzTypE import at.mocode.shared.serializers.UuidSerializer import com.benasher44.uuid.Uuid import com.benasher44.uuid.uuid4 @@ -13,5 +13,5 @@ data class Platz( var name: String, var dimension: String?, var boden: String?, - var typ: PlatzTyp + var typ: PlatzTypE ) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt index 99020f6f..6163d847 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/Turnier.kt @@ -31,7 +31,7 @@ data class Turnier( var datumBis: LocalDate, @Serializable(with = KotlinLocalDateTimeSerializer::class) // Beispiel var nennungsschluss: LocalDateTime?, - var nennungsArt: List = emptyList(), + var nennungsArt: List = emptyList(), var nennungsHinweis: String?, var eigenesNennsystemUrl: String?, @Serializable(with = BigDecimalSerializer::class) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt index a9509475..27ffae19 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/Veranstaltung.kt @@ -1,6 +1,6 @@ package at.mocode.shared.model -import at.mocode.shared.enums.VeranstalterTyp +import at.mocode.shared.enums.VeranstalterTypE import at.mocode.shared.serializers.KotlinInstantSerializer import at.mocode.shared.serializers.KotlinLocalDateSerializer import at.mocode.shared.serializers.UuidSerializer @@ -22,7 +22,7 @@ data class Veranstaltung( var datumBis: LocalDate, var veranstalterName: String, var veranstalterOepsNummer: String?, - var veranstalterTyp: VeranstalterTyp = VeranstalterTyp.UNBEKANNT, + var veranstalterTypE: VeranstalterTypE = VeranstalterTypE.UNBEKANNT, var veranstaltungsortName: String, var veranstaltungsortAdresse: String, var kontaktpersonName: String?, diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomLizenz.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomLizenz.kt new file mode 100644 index 00000000..9200af49 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomLizenz.kt @@ -0,0 +1,55 @@ +import at.mocode.shared.serializers.KotlinInstantSerializer +import at.mocode.shared.serializers.KotlinLocalDateSerializer +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.datetime.LocalDate +import kotlinx.serialization.Serializable + +/** + * Repräsentiert eine spezifische Lizenz oder Qualifikation, die einer Person (`DomPerson`) + * zugeordnet ist. + * + * Diese Entität verknüpft eine Person mit einer globalen Lizenzdefinition (`LizenzTypGlobal`) + * und speichert zusätzliche Informationen wie die Gültigkeit. + * Die Informationen stammen aus der Verarbeitung der Roh-Lizenzfelder + * (insb. `lizenzinfoRawOepsRoh`) aus `Person_ZNS_Staging`. + * + * @property lizenzId Eindeutiger interner Identifikator für diese zugeordnete Lizenz (UUID). + * @property personId Fremdschlüssel zur `DomPerson`, der diese Lizenz besitzt. + * @property lizenzTypGlobalId Fremdschlüssel zum `LizenzTypGlobal`, der die Art dieser Lizenz definiert. + * @property gueltigBisJahr Das Jahr, bis zu dem diese Lizenz (basierend auf der letzten Zahlung im ZNS) gültig ist. + * @property ausgestelltAm Optionales Datum, an dem diese spezifische Lizenz für die Person ausgestellt wurde (nicht immer aus ZNS ersichtlich). + * @property istAktivBezahltOeps Gibt an, ob diese Lizenz als "aktiv/bezahlt" aus den OEPS-Daten (primär LIZENZINFO) hervorgeht. + * @property notiz Interne Anmerkungen zu dieser spezifischen Lizenzzuordnung. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class DomLizenz( + @Serializable(with = UuidSerializer::class) + val lizenzId: Uuid = uuid4(), + + @Serializable(with = UuidSerializer::class) + val personId: Uuid, // FK zu DomPerson.personId + + @Serializable(with = UuidSerializer::class) + val lizenzTypGlobalId: Uuid, // FK zu LizenzTypGlobal.lizenzTypGlobalId + + var gueltigBisJahr: Int?, // Aus Person_ZNS_Staging.jahrLetzteZahlungLizenzOepsRoh + + @Serializable(with = KotlinLocalDateSerializer::class) + var ausgestelltAm: LocalDate? = null, // Nicht direkt in LIZENZ01.dat, ggf. manuell oder andere Quelle + + var istAktivBezahltOeps: Boolean = false, // Wird gesetzt, wenn die Lizenz aus LIZENZINFO stammt + // oder als Hauptlizenz aktiv ist. + + var notiz: String? = null, + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPerson.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomPerson.kt similarity index 97% rename from shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPerson.kt rename to shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomPerson.kt index e6b413a2..6385732f 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPerson.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomPerson.kt @@ -23,7 +23,7 @@ import kotlinx.serialization.Serializable * @property vorname Vorname der Person. * @property titel Akademischer Titel oder Anrede (z.B. Dr., Ing.). * @property geburtsdatum Geburtsdatum der Person. - * @property geschlecht Geschlecht der Person. + * @property geschlechtE Geschlecht der Person. * @property nationalitaetLandId Fremdschlüssel zur `LandDefinition` für die Nationalität. * @property feiId Optionale FEI-Identifikationsnummer der Person. * @property telefon Private oder geschäftliche Telefonnummer. @@ -59,7 +59,7 @@ data class DomPerson( @Serializable(with = KotlinLocalDateSerializer::class) var geburtsdatum: LocalDate? = null, // Konvertiert aus Person_ZNS_Staging.geburtsdatumTextRoh - var geschlecht: GeschlechtE? = null, // Konvertiert aus Person_ZNS_Staging.geschlechtCodeRoh + var geschlechtE: GeschlechtE? = null, // Konvertiert aus Person_ZNS_Staging.geschlechtCodeRoh @Serializable(with = UuidSerializer::class) var nationalitaetLandId: Uuid? = null, // Aufgelöst aus Person_ZNS_Staging.nationalitaetCodeRoh via LandDefinition diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPferd.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomPferd.kt similarity index 100% rename from shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomPferd.kt rename to shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomPferd.kt diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomQualifikation.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomQualifikation.kt new file mode 100644 index 00000000..5be0e77a --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomQualifikation.kt @@ -0,0 +1,56 @@ +import at.mocode.shared.serializers.KotlinInstantSerializer +import at.mocode.shared.serializers.KotlinLocalDateSerializer +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.datetime.LocalDate +import kotlinx.serialization.Serializable + +/** + * Repräsentiert eine spezifische Funktionärsqualifikation, die einer Person (`DomPerson`) + * zugeordnet ist. + * + * Diese Entität verknüpft eine Person mit einer globalen Qualifikationsdefinition (`QualifikationsTyp`) + * und kann zusätzliche Informationen wie eine spezifische Bemerkung oder Gültigkeit speichern. + * Die Informationen stammen primär aus der Verarbeitung der Roh-Qualifikationskürzel + * aus `Person_ZNS_Staging.qualifikationenRawOepsRoh` (welches aus `RICHT01.dat` befüllt wird). + * + * @property qualifikationId Eindeutiger interner Identifikator für diese zugeordnete Qualifikation (UUID). + * @property personId Fremdschlüssel zur `DomPerson`, die diese Qualifikation besitzt. + * @property qualTypId Fremdschlüssel zum `QualifikationsTyp`, der die Art dieser Qualifikation definiert. + * @property bemerkung Optionale Bemerkungen zu dieser spezifischen Qualifikation der Person + * (z.B. spezifische Einsatzbereiche, Einschränkungen). + * @property gueltigVon Optionales Datum, ab wann diese Qualifikation für die Person gültig ist. + * @property gueltigBis Optionales Datum, bis wann diese Qualifikation für die Person gültig ist. + * @property istAktiv Gibt an, ob diese Qualifikation für die Person aktuell als aktiv betrachtet wird. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class DomQualifikation( + @Serializable(with = UuidSerializer::class) + val qualifikationId: Uuid = uuid4(), + + @Serializable(with = UuidSerializer::class) + val personId: Uuid, // FK zu DomPerson.personId + + @Serializable(with = UuidSerializer::class) + val qualTypId: Uuid, // FK zu QualifikationsTyp.qualTypId + + var bemerkung: String? = null, + + @Serializable(with = KotlinLocalDateSerializer::class) + var gueltigVon: LocalDate? = null, // Nicht direkt in RICHT01.dat, aber evtl. für manuelle Pflege + + @Serializable(with = KotlinLocalDateSerializer::class) + var gueltigBis: LocalDate? = null, // Nicht direkt in RICHT01.dat + + var istAktiv: Boolean = true, // Standardmäßig aktiv, wenn importiert + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomVerein.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomVerein.kt similarity index 98% rename from shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomVerein.kt rename to shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomVerein.kt index 009a0028..36da4900 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/verein/DomVerein.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/domaene/DomVerein.kt @@ -1,4 +1,4 @@ -package at.mocode.shared.model.domaene.verein +package at.mocode.shared.model.domaene import at.mocode.shared.enums.DatenQuelleE import at.mocode.shared.serializers.KotlinInstantSerializer diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Platz.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Platz.kt new file mode 100644 index 00000000..a3ebd2a7 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Platz.kt @@ -0,0 +1,48 @@ +import at.mocode.shared.enums.PlatzTypE +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 + +/** + * Repräsentiert einen physischen Platz auf einer Reitanlage, der für verschiedene Zwecke + * im Rahmen einer Pferdesportveranstaltung genutzt werden kann. + * + * @property platzId Eindeutiger interner Identifikator für diesen Platz (UUID). + * @property name Der Name oder die Bezeichnung des Platzes. + * @property typ Die Art des Platzes (z.B. AUSTRAGUNG, VORBEREITUNG). + * @property laengeMeter Optionale Angabe der Länge des Platzes in Metern. + * @property breiteMeter Optionale Angabe der Breite des Platzes in Metern. + * @property bodenbelag Beschreibung des Bodenbelags. + * @property ueberdacht Gibt an, ob der Platz überdacht ist. + * @property beleuchtungVorhanden Gibt an, ob eine Beleuchtung für den Platz vorhanden ist. + * @property istAktiv Gibt an, ob dieser Platz aktuell verfügbar und nutzbar ist. + * @property notizen Interne Notizen oder zusätzliche Informationen zum Platz. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class Platz( + @Serializable(with = UuidSerializer::class) + val platzId: Uuid = uuid4(), + + var name: String, + var typ: PlatzTypE, + + var laengeMeter: Double? = null, + var breiteMeter: Double? = null, + var bodenbelag: String? = null, + var ueberdacht: Boolean? = null, + var beleuchtungVorhanden: Boolean? = null, + + var istAktiv: Boolean = true, + var notizen: String? = null, + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_Abteilung.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_Abteilung.kt new file mode 100644 index 00000000..89923d67 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_Abteilung.kt @@ -0,0 +1,130 @@ +import at.mocode.shared.enums.BeginnzeitTypE +import at.mocode.shared.enums.PlatzTypE +import at.mocode.shared.model.DotierungsAbstufung +import at.mocode.shared.serializers.BigDecimalSerializer +import at.mocode.shared.serializers.KotlinInstantSerializer +import at.mocode.shared.serializers.KotlinLocalDateSerializer +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 + +/** + * Repräsentiert eine spezifische Abteilung innerhalb einer Prüfung (`Pruefung_OEPS`). + * Eine Prüfung kann in eine oder mehrere Abteilungen unterteilt sein, basierend auf + * Kriterien wie Lizenzstufen, Altersklassen, Pferdeeigenschaften etc. + * Nennungen, Startlisten und Ergebnislisten beziehen sich primär auf diese Abteilungen. + * + * @property pruefungAbteilungDbId Eindeutiger interner Identifikator für diese Abteilung (UUID). + * @property pruefungDbId Fremdschlüssel zur übergeordneten `Pruefung_OEPS`. + * @property abteilungsKennzeichen Ein Kennzeichen für diese Abteilung innerhalb der Prüfung (z.B. "1", "A", "R1"). + * Wird oft zur Erstellung der vollständigen Bewerbsnummer verwendet (z.B. "12/1"). + * @property bezeichnungOeffentlich Die offizielle Bezeichnung dieser Abteilung, wie sie auf Listen erscheinen soll + * (z.B. "R1 Reiter", "Lizenzfrei", "Junioren"). Falls leer, kann sie aus der + * Bezeichnung der Hauptprüfung und dem Kennzeichen abgeleitet werden. + * @property bezeichnungIntern Interne Bezeichnung oder Notiz zur Abteilung. + * @property teilKritMinLizenzStammdatumId Optionaler FK zu `Sportfachliche_Stammdaten` (Typ LIZENZTYP_OEPS_STUFE), + * der die Mindestlizenz für diese Abteilung definiert. + * @property teilKritMaxLizenzStammdatumId Optionaler FK für die Maximallizenz. + * @property teilKritErlaubteLizenzenStammdatenIds Liste von FKs zu `Sportfachliche_Stammdaten` (Typ LIZENZTYP_OEPS), + * die die exakt erlaubten Lizenzen definieren. + * @property teilKritMinPferdealter Mindestalter der Pferde für diese Abteilung. + * @property teilKritMaxPferdealter Maximalalter der Pferde für diese Abteilung. + * @property teilKritAltersklasseReiterStammdatumId FK zu `Sportfachliche_Stammdaten` (Typ ALTERSCLASSEN_DEFINITION), + * der die Altersklasse der Reiter definiert. + * @property teilKritPferderasseStammdatumId FK zu `Sportfachliche_Stammdaten` (Typ PFERDERASSE), + * der die erlaubte Pferderasse definiert. + * @property teilKritAnzahlStarterMin Optionale Mindestanzahl an Startern für diese Abteilung. + * @property teilKritAnzahlStarterMax Optionale Maximalanzahl an Startern für diese Abteilung. + * @property teilKritFreiTextBeschreibung Freitextliche Beschreibung weiterer oder spezieller Teilungskriterien. + * @property startgeld Überschreibt ggf. das Standard-Startgeld der `Pruefung_OEPS` für diese Abteilung. + * @property dotierungen Spezifische Dotierungsabstufungen für diese Abteilung. + * @property platzId Optionaler Fremdschlüssel zum `Platz`, falls diese Abteilung auf einem anderen Platz + * als dem Standardplatz der `Pruefung_OEPS` stattfindet. + * @property datum Optionales spezifisches Datum für diese Abteilung. + * @property beginnzeitTyp Typ der geplanten Beginnzeit für diese Abteilung. + * @property beginnzeitFix Fixe Beginnzeit, falls Typ FIX_UM. + * @property beginnNachAbteilungOderPruefungId Fremdschlüssel zu einer anderen `Pruefung_Abteilung` oder `Pruefung_OEPS`, + * nach der diese Abteilung starten soll. + * @property beginnzeitCa Ungefähre Beginnzeit, falls Typ CA_UM. + * @property dauerProStartGeschaetztSek Geschätzte Dauer pro Starter in Sekunden für diese Abteilung. + * Überschreibt ggf. Werte aus `Pruefung_OEPS` oder den spartspezifischen Details. + * @property umbauzeitNachAbteilungMin Umbauzeit in Minuten nach dieser Abteilung. + * @property besichtigungszeitVorAbteilungMin Besichtigungszeit in Minuten vor dieser Abteilung. + * @property stechzeitZusaetzlichMin Zusatzzeit für ein eventuelles Stechen in Minuten für diese Abteilung. + * @property istAktivFuerNennung Gibt an, ob für diese Abteilung Nennungen entgegengenommen werden können. + * @property istStartlisteFinal Gibt an, ob die Startliste für diese Abteilung finalisiert wurde. + * @property istErgebnislisteFinal Gibt an, ob die Ergebnisliste für diese Abteilung finalisiert wurde. + * @property anzahlNennungen Informativ: Aktuelle Anzahl der Nennungen für diese Abteilung. + * @property anzahlStarterEffektiv Informativ: Tatsächliche Anzahl der Starter. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class Pruefung_Abteilung( + @Serializable(with = UuidSerializer::class) + val pruefungAbteilungDbId: Uuid = uuid4(), + + @Serializable(with = UuidSerializer::class) + val pruefungDbId: Uuid, // FK zu Pruefung_OEPS.pruefungDbId + + var abteilungsKennzeichen: String, // z.B. "1", "A", "R1" + var bezeichnungOeffentlich: String? = null, + var bezeichnungIntern: String? = null, + + // Strukturierte Teilungskriterien (Verweise auf Sportfachliche_Stammdaten) + @Serializable(with = UuidSerializer::class) + var teilKritMinLizenzStammdatumId: Uuid? = null, // Typ LIZENZTYP_OEPS_STUFE + @Serializable(with = UuidSerializer::class) + var teilKritMaxLizenzStammdatumId: Uuid? = null, // Typ LIZENZTYP_OEPS_STUFE + var teilKritErlaubteLizenzenStammdatenIds: List<@Serializable(with = UuidSerializer::class) Uuid>? = null, // Typ LIZENZTYP_OEPS + var teilKritMinPferdealter: Int? = null, + var teilKritMaxPferdealter: Int? = null, + @Serializable(with = UuidSerializer::class) + var teilKritAltersklasseReiterStammdatumId: Uuid? = null, // Typ ALTERSCLASSEN_DEFINITION + @Serializable(with = UuidSerializer::class) + var teilKritPferderasseStammdatumId: Uuid? = null, // Typ PFERDERASSE + var teilKritAnzahlStarterMin: Int? = null, + var teilKritAnzahlStarterMax: Int? = null, + var teilKritFreiTextBeschreibung: String? = null, + + // Abteilungsspezifische Überschreibungen + @Serializable(with = BigDecimalSerializer::class) + var startgeld: BigDecimal? = null, // Überschreibt Pruefung_OEPS.startgeldStandard + var dotierungen: List = emptyList(), // Eigene Dotierung, erbt sonst von Pruefung_OEPS + + // Zeitplanung (überschreibt ggf. Werte aus Pruefung_OEPS oder deren spartspez. Details) + @Serializable(with = UuidSerializer::class) + var platzId: Uuid?, // FK zu Platz.platzId + @Serializable(with = KotlinLocalDateSerializer::class) + var datum: LocalDate?, + var beginnzeitTyp: BeginnzeitTypE = BeginnzeitTypE.ANSCHLIESSEND, + @Serializable(with = KotlinLocalTimeSerializer::class) + var beginnzeitFix: LocalTime? = null, + @Serializable(with = UuidSerializer::class) + var beginnNachAbteilungOderPruefungId: Uuid?, // Kann ID einer anderen Pruefung_Abteilung oder Pruefung_OEPS sein + @Serializable(with = KotlinLocalTimeSerializer::class) + var beginnzeitCa: LocalTime? = null, + var dauerProStartGeschaetztSek: Int? = null, + var umbauzeitNachAbteilungMin: Int? = null, + var besichtigungszeitVorAbteilungMin: Int? = null, + var stechzeitZusaetzlichMin: Int? = null, + + var istAktivFuerNennung: Boolean = true, + var istStartlisteFinal: Boolean = false, + var istErgebnislisteFinal: Boolean = false, + + var anzahlNennungen: Int = 0, // Wird dynamisch befüllt oder periodisch aktualisiert + var anzahlStarterEffektiv: Int = 0, // Wird dynamisch befüllt + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_OEPS.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_OEPS.kt new file mode 100644 index 00000000..3a85e8ba --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Pruefung_OEPS.kt @@ -0,0 +1,92 @@ +import at.mocode.shared.enums.BeginnzeitTypE +import at.mocode.shared.enums.SparteE +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 + +/** + * Repräsentiert die Basis-Informationen eines Bewerbs (einer Prüfung) innerhalb eines Turniers. + * Diese Entität enthält spartenübergreifende Attribute. Spartenspezifische Details + * werden in separaten, verknüpften Entitäten gespeichert (z.B. `DressurPruefungSpezifika`). + * + * @property pruefungDbId Eindeutiger interner Identifikator für diese Prüfung/diesen Bewerb (UUID). + * @property turnierOepsId Fremdschlüssel zum übergeordneten `Turnier_OEPS`. + * @property oepsBewerbNrAnzeige Die offizielle Nummer des Bewerbs gemäß Ausschreibung (z.B. 1, 12). + * @property nameTextUebergeordnet Die Hauptbezeichnung des Bewerbs/der Prüfung + * (z.B. "Dressurprüfung", "Standardspringprüfung"). + * @property sparte Die Pferdesportsparte dieses Bewerbs (DRESSUR, SPRINGEN, etc.). + * Wird beim Anlegen gesetzt, ggf. vorgeschlagen aus der gewählten ÖTO-Kategorie. + * @property oepsKategorieStammdatumId Fremdschlüssel zu `Sportfachliche_Stammdaten` (Typ BEWERBSKATEGORIE_OETO), + * die die spezifische ÖTO-Kategorie dieses Bewerbs definiert (z.B. "CDN-C Neu"). + * @property istDotiert Gibt an, ob dieser Bewerb grundsätzlich mit Geldpreisen dotiert ist. + * Details zur Dotierung können in der Abteilung oder spartspezifisch festgelegt werden. + * @property startgeldStandard Ein Standard-Startgeld für diesen Bewerb. Kann von der Abteilung oder + * spartspezifischen Regeln überschrieben werden. + * @property oepsBewerbsartCodeZns Optionaler OEPS-Code für die Art des Bewerbs, relevant für den ZNS-Export. + * @property notizenIntern Interne Notizen oder Kommentare zu diesem Bewerb. + * @property istAbgesagt Gibt an, ob der Bewerb abgesagt wurde. + * @property erfordertAbteilungsAuswahlFuerNennung Gibt an, ob für Nennungen zu diesem Bewerb + * zwingend eine spezifische Abteilung ausgewählt werden muss (true), oder ob Nennungen direkt + * zum Bewerb (implizit zur Default-Abteilung) erfolgen können (false). + * @property standardPlatzId Optionaler Default-Austragungsort (FK zu `Platz`) für diesen Bewerb. + * Kann von der Abteilung überschrieben werden. + * @property standardDatum Optionales Default-Datum für diesen Bewerb. Kann von der Abteilung überschrieben werden. + * @property standardBeginnzeitTyp Default-Typ für die geplante Beginnzeit. + * @property standardBeginnzeitFix Default-fixe Beginnzeit, falls Typ FIX_UM. + * @property standardBeginnNachPruefungId Default-Verweis auf eine andere Pruefung_OEPS (deren letzte Abteilung), + * falls Typ ANSCHLIESSEND oder NACH_VORHERIGEM_BEWERB_ABTEILUNG. + * @property standardBeginnzeitCa Default-ungefähre Beginnzeit, falls Typ CA_UM. + * @property anzahlAbteilungen Die Anzahl der für diesen Bewerb definierten Abteilungen (informativ). + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class Pruefung_OEPS( // Unsere BewerbBasis + @Serializable(with = UuidSerializer::class) + val pruefungDbId: Uuid = uuid4(), + + @Serializable(with = UuidSerializer::class) + val turnierOepsId: Uuid, // Umbenannt von turnier_db_id für Konsistenz + + var oepsBewerbNrAnzeige: Int, // Deine nummerInAusschreibung + var nameTextUebergeordnet: String, + var sparte: SparteE, // Explizit, kann aus oepsKategorieStammdatumId vorgeschlagen werden + + @Serializable(with = UuidSerializer::class) + var oepsKategorieStammdatumId: Uuid, // FK zu Sportfachliche_Stammdaten (Typ BEWERBSKATEGORIE_OETO) + + var istDotiert: Boolean = false, + @Serializable(with = BigDecimalSerializer::class) + var startgeldStandard: BigDecimal? = null, + + var oepsBewerbsartCodeZns: String? = null, + var notizenIntern: String? = null, + var istAbgesagt: Boolean = false, + var erfordertAbteilungsAuswahlFuerNennung: Boolean = true, // Default: Nennung nur für spezifische Abteilung + + // Standard-Zeitplanungswerte (können von Abteilung oder spartspez. Details überschrieben werden) + @Serializable(with = UuidSerializer::class) + var standardPlatzId: Uuid? = null, + @Serializable(with = KotlinLocalDateSerializer::class) + var standardDatum: LocalDate? = null, + var standardBeginnzeitTyp: BeginnzeitTypE = BeginnzeitTypE.ANSCHLIESSEND, + @Serializable(with = KotlinLocalTimeSerializer::class) + var standardBeginnzeitFix: LocalTime? = null, + @Serializable(with = UuidSerializer::class) + var standardBeginnNachPruefungId: Uuid? = null, // Verweis auf Pruefung_OEPS.pruefungDbId + @Serializable(with = KotlinLocalTimeSerializer::class) + var standardBeginnzeitCa: LocalTime? = null, + + var anzahlAbteilungen: Int = 0, // Wird berechnet oder bei Erstellung der Abteilungen gesetzt + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_OEPS.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_OEPS.kt new file mode 100644 index 00000000..0cbc4f76 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_OEPS.kt @@ -0,0 +1,125 @@ +import at.mocode.shared.enums.EventStatusE +import at.mocode.shared.enums.NennungsArtE +import at.mocode.shared.enums.RegelwerkTypE +import at.mocode.shared.enums.SparteE +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 kotlinx.datetime.Clock +import kotlinx.datetime.Instant +import kotlinx.datetime.LocalDate +import kotlinx.datetime.LocalDateTime +import kotlinx.serialization.Serializable + +/** + * Repräsentiert ein spezifisches, vom zuständigen Verband (OEPS, FEI) genehmigtes Turnier + * innerhalb eines Veranstaltungsrahmens. Enthält alle turnierspezifischen Informationen + * gemäß Ausschreibung und die für den Turnierbericht relevanten Daten. + * + * @property turnierOepsId Eindeutiger interner Identifikator für dieses Turnier (UUID). + * @property veranstaltungsRahmenId Fremdschlüssel zum übergeordneten `VeranstaltungsRahmen`. + * @property oepsTurnierNr Die offizielle OEPS-Turniernummer (z.B. "25319"). Sollte eindeutig sein. + * @property titel Der offizielle Titel des Turniers laut Ausschreibung + * (z.B. "CSN-C NEU CSNP-C NEU NEUMARKT/M., OÖ"). + * @property untertitel Optionaler Untertitel oder Zusatzbezeichnung für das Turnier. + * @property hauptsparte Die primäre Pferdesportsparte dieses Turniers (z.B. SPRINGEN, DRESSUR). + * Auch wenn Bewerbe anderer Sparten stattfinden können, gibt es meist eine Hauptausrichtung. + * @property oetoKategorieStammdatenIds Liste von Fremdschlüsseln zu `Sportfachliche_Stammdaten` (Typ BEWERBSKATEGORIE_OETO), + * die die offiziellen ÖTO-Kategorien dieses Turniers definieren (z.B. ["CDN-C Neu", "CDNP-C Neu"]). + * @property regelwerkTyp Das primär für dieses Turnier geltende Regelwerk (ÖTO, FEI). + * @property datumVon Spezifisches Startdatum dieses Turniers. + * @property datumBis Spezifisches Enddatum dieses Turniers. + * @property nennschlussNenndatei Zeitlicher Nennschluss für die vom OEPS bereitgestellte Nenndatei (n2). + * @property nennschlussOffiziell Offizieller Nennschluss laut Ausschreibung. + * @property nennungsArtBevorzugt Die bevorzugte Art der Nennung für dieses Turnier (z.B. Online-Portal, ZNS). + * @property nennungsHinweisText Wichtige Hinweise zur Nennung direkt aus der Ausschreibung. + * @property pdfAusschreibungUrl URL oder Pfad zur offiziellen PDF-Ausschreibung. + * @property kommentarIntern Interne Notizen oder Kommentare zum Turnier für die Meldestelle. + * @property typNationalInternational Kennzeichnung, ob es sich um ein nationales oder internationales Turnier handelt. + * @property spracheDefault Hauptsprache für Dokumente und Kommunikation dieses Turniers. + * @property startnummernVerwenden Gibt an, ob Startnummern (zusätzlich zu Kopfnummern) verwendet werden. + * @property nennungUeberZnsMoeglichOeps Info, ob dieses Turnier über das OEPS eZNS nennbar ist/war. + * @property erhebeNachnennungsgebuehr Gibt an, ob eine Nachnenngebühr erhoben wird. + * @property erhebeNennungstauschgebuehr Gibt an, ob eine Gebühr für Pferd-/Reitertausch erhoben wird. + * @property logoTurnierUrl URL oder Pfad zu einem spezifischen Logo für dieses Turnier. + * @property turnierleiterDomPersonId Fremdschlüssel zur `DomPerson` des Turnierleiters. + * @property turnierbeauftragterDomPersonId Fremdschlüssel zur `DomPerson` des Turnierbeauftragten (TBA). + * @property meldestelleTelefon Telefonnummer der Meldestelle für dieses Turnier. + * @property meldestelleOeffnungszeiten Öffnungszeiten der Meldestelle. + * @property startUndErgebnislistenUrl URL, unter der Start- und Ergebnislisten veröffentlicht werden. + * @property istBoxenMoeglich Gibt an, ob eine Einstallung/Boxenreservierung möglich ist. + * @property anmerkungBoxen Details zu den Boxen (Anzahl, Preis, Reservierung etc.). + * @property defaultDauerProStarterSek Standarddauer pro Starter in Sekunden (kann von Bewerb/Abteilung überschrieben werden). + * @property defaultUmbauzeitMin Standard-Umbauzeit zwischen Bewerben in Minuten. + * @property defaultBesichtigungszeitMin Standard-Besichtigungszeit (z.B. Parcours) in Minuten. + * @property defaultStechzeitMin Standard-Zusatzzeit für ein Stechen in Minuten. + * @property statusTurnier Aktueller Status des Turniers (analog zu EventStatusE, aber für das Turnier). + * @property berichtAnmerkungDopingkontrollen Textfeld für den Turnierbericht. + * @property berichtDopingboxVorhanden Boolean für den Turnierbericht. + * @property berichtPferdepasskontrollenBeiBewerb Textfeld für den Turnierbericht. + * @property berichtPferdepasskontrollenBeanstandungen Textfeld für den Turnierbericht. + * @property berichtAnmerkungMeldestelleFunktion Textfeld für den Turnierbericht. + * @property berichtAnmerkungZeitnehmungFunktion Textfeld für den Turnierbericht. + * @property berichtAnzeigetafelInfo Textfeld für den Turnierbericht. + * @property berichtZuschauertribueneInfo Textfeld für den Turnierbericht. + * @property berichtStallungenInfo Textfeld für den Turnierbericht. + * @property berichtAblaufBesonderheitenUnfaelleProteste Textfeld für den Turnierbericht. + * @property berichtBesondereVorkommnisse Textfeld für den Turnierbericht. + * @property berichtVerbesserungsvorschlaege Textfeld für den Turnierbericht. + * @property berichtGesamteindruck Textfeld für den Turnierbericht. + * @property berichtNennlisteMitSperrlisteGeprueft Boolean für den Turnierbericht. + * @property berichtNennlisteBeanstandungen Textfeld für den Turnierbericht. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class Turnier_OEPS( // Behält deinen Namen bei + @Serializable(with = UuidSerializer::class) + val turnierOepsId: Uuid = uuid4(), + + @Serializable(with = UuidSerializer::class) + val veranstaltungsRahmenId: Uuid, + + var oepsTurnierNr: String, + var titel: String, + var untertitel: String? = null, + var hauptsparte: SparteE, + + // Hier verwenden wir direkt List. Der Serializer für Uuid selbst (@Serializable(with = UuidSerializer::class) an der Uuid-Klasse) + // sollte es kotlinx.serialization ermöglichen, auch Listen davon zu behandeln. + var oetoKategorieStammdatenIds: List<@Serializable(with = UuidSerializer::class) Uuid>, + + var regelwerkTyp: RegelwerkTypE = RegelwerkTypE.OETO, + @Serializable(with = KotlinLocalDateSerializer::class) + var datumVon: LocalDate, + @Serializable(with = KotlinLocalDateSerializer::class) + var datumBis: LocalDate, + + @Serializable(with = KotlinLocalDateTimeSerializer::class) + var nennschlussOffiziell: LocalDateTime? = null, // Nur der offizielle Nennschluss lt. Ausschreibung + + var pdfAusschreibungUrl: String? = null, + var kommentarIntern: String? = null, + var typNationalInternational: String = "National", + var spracheDefault: String = "Deutsch", + var logoTurnierUrl: String? = null, + + @Serializable(with = UuidSerializer::class) + var turnierleiterDomPersonId: Uuid? = null, + @Serializable(with = UuidSerializer::class) + var turnierbeauftragterDomPersonId: Uuid? = null, + + var meldestelleTelefon: String? = null, + var meldestelleOeffnungszeiten: String? = null, + var startUndErgebnislistenUrl: String? = null, // Kann auch dynamisch generiert werden + + var statusTurnier: EventStatusE = EventStatusE.IN_PLANUNG, // Wiederverwendung EventStatusE + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_hat_Platz.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_hat_Platz.kt new file mode 100644 index 00000000..abf25216 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/Turnier_hat_Platz.kt @@ -0,0 +1,26 @@ +import at.mocode.shared.serializers.UuidSerializer +import com.benasher44.uuid.Uuid +import kotlinx.serialization.Serializable + +/** + * Verknüpft ein Turnier (`Turnier_OEPS`) mit einem genutzten Platz (`Platz`) + * und beschreibt den spezifischen Verwendungszweck dieses Platzes im Kontext des Turniers. + * + * @property turnierOepsId Fremdschlüssel zum `Turnier_OEPS`. Teil des zusammengesetzten Primärschlüssels. + * @property platzId Fremdschlüssel zum `Platz`. Teil des zusammengesetzten Primärschlüssels. + * @property verwendungszweck Beschreibung, wofür der Platz bei diesem Turnier genutzt wird. + * @property istHauptAustragungsplatz Optionales Flag, um den primären Austragungsplatz zu kennzeichnen. + * @property istHauptVorbereitungsplatz Optionales Flag, um den primären Vorbereitungsplatz zu kennzeichnen. + */ +@Serializable +data class Turnier_hat_Platz( + @Serializable(with = UuidSerializer::class) + val turnierOepsId: Uuid, // Teil des PK, FK zu Turnier_OEPS.turnierOepsId + + @Serializable(with = UuidSerializer::class) + val platzId: Uuid, // Teil des PK, FK zu Platz.platzId + + var verwendungszweck: String? = null, + var istHauptAustragungsplatz: Boolean? = false, + var istHauptVorbereitungsplatz: Boolean? = false +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/VeranstaltungsRahmen.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/VeranstaltungsRahmen.kt new file mode 100644 index 00000000..81d63b4d --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/VeranstaltungsRahmen.kt @@ -0,0 +1,82 @@ +package at.mocode.shared.model.veranstaltung + +import at.mocode.shared.enums.EventStatusE +import at.mocode.shared.serializers.KotlinInstantSerializer +import at.mocode.shared.serializers.KotlinLocalDateSerializer +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.datetime.LocalDate +import kotlinx.serialization.Serializable + +/** + * Definiert den übergeordneten Rahmen einer Veranstaltung (z.B. ein Turnierwochenende), + * der ein oder mehrere spezifische OEPS-Turniere umfassen kann. + * + * @property veranstRahmenId Eindeutiger interner Identifikator für diesen Veranstaltungsrahmen (UUID). + * @property name Die offizielle oder werbewirksame Bezeichnung des Veranstaltungsrahmens + * (z.B. "Neumarkter Pferdesporttage 2025", "Pfingstturnier Sudenhof"). + * @property eventTypIntern Optionale interne Klassifizierung des Events + * (z.B. "StandardWochenende", "Meisterschaftsevent", "Cupveranstaltung"). + * @property ortName Name der Anlage oder des Hauptortes der Veranstaltung (z.B. "Reitanlage Stroblmair"). + * @property ortStrasse Straße und Hausnummer des Veranstaltungsortes. + * @property ortPlz Postleitzahl des Veranstaltungsortes. + * @property ortOrt Ortschaft des Veranstaltungsortes. + * @property datumVonGesamt Startdatum des gesamten Veranstaltungsrahmens. + * @property datumBisGesamt Enddatum des gesamten Veranstaltungsrahmens. + * @property logoUrl Optionaler URL-Pfad zu einem Logo für den Veranstaltungsrahmen. + * @property webseiteUrl Optionale URL zur Webseite des Veranstaltungsrahmens oder des Veranstalters. + * @property hauptveranstalterDomVereinId Optionale Verknüpfung zum `DomVerein`, + * der als Hauptveranstalter dieses Rahmenevents auftritt. + * @property hauptKontaktpersonDomPersonId Optionale Verknüpfung zur `DomPerson`, + * die als Hauptansprechpartner für den gesamten Veranstaltungsrahmen dient. + * @property status Aktueller Status des Veranstaltungsrahmens (z.B. in Planung, genehmigt, aktiv). + * @property anmerkungenAllgemein Allgemeine Notizen oder Beschreibungen zum Veranstaltungsrahmen. + * @property berichtAnmerkungSanitaer Anmerkungen zu sanitären Anlagen für den Turnierbericht. + * @property berichtAnmerkungParkenEntladen Anmerkungen zu Park- und Entlademöglichkeiten. + * @property berichtAnmerkungSponsorenBetreuung Anmerkungen zur Sponsorenbetreuung. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class VeranstaltungsRahmen( + @Serializable(with = UuidSerializer::class) + val veranstRahmenId: Uuid = uuid4(), + + var name: String, + var eventTypIntern: String? = null, + + var ortName: String, // Kombiniert aus deinem ort_text oder spezifischer + var ortStrasse: String? = null, + var ortPlz: String? = null, + var ortOrt: String? = null, // Genauer Ort + + @Serializable(with = KotlinLocalDateSerializer::class) + var datumVonGesamt: LocalDate, + @Serializable(with = KotlinLocalDateSerializer::class) + var datumBisGesamt: LocalDate, + + var logoUrl: String? = null, + var webseiteUrl: String? = null, + + @Serializable(with = UuidSerializer::class) + var hauptveranstalterDomVereinId: Uuid? = null, // FK zu DomVerein.vereinId + + @Serializable(with = UuidSerializer::class) + var hauptKontaktpersonDomPersonId: Uuid? = null, // FK zu DomPerson.personId + + var status: EventStatusE = EventStatusE.IN_PLANUNG, + var anmerkungenAllgemein: String? = null, + + // Felder für übergreifende Turnierbericht-Aspekte + var berichtAnmerkungSanitaer: String? = null, + var berichtAnmerkungParkenEntladen: String? = null, + var berichtAnmerkungSponsorenBetreuung: String? = null, + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/MCS_Wertungspruefung.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/MCS_Wertungspruefung.kt new file mode 100644 index 00000000..27b2e5e7 --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/MCS_Wertungspruefung.kt @@ -0,0 +1,41 @@ +import at.mocode.shared.enums.CupSerieTypE +import at.mocode.shared.enums.SparteE +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.benasher44.uuid.uuid4 +import com.ionspin.kotlin.bignum.decimal.BigDecimal +import kotlinx.datetime.Clock +import kotlinx.datetime.Instant +import kotlinx.serialization.Serializable + +/** + * Verknüpft eine Meisterschaft/Cup/Serie (`Meisterschaft_Cup_Serie`) mit einer spezifischen + * Prüfungsabteilung (`Pruefung_Abteilung`), die als Wertungsprüfung für diesen + * übergreifenden Wettbewerb zählt. + * + * @property mcsId Fremdschlüssel zur `Meisterschaft_Cup_Serie`. Teil des zusammengesetzten Primärschlüssels. + * @property pruefungAbteilungDbId Fremdschlüssel zur `Pruefung_Abteilung`. Teil des zusammengesetzten Primärschlüssels. + * @property faktorFuerWertung Ein optionaler Faktor, mit dem das Ergebnis dieser Wertungsprüfung + * in die Gesamtwertung des Cups/der Meisterschaft einfließt (Default ist 1.0). + * @property bemerkung Optionale Bemerkung zu dieser spezifischen Wertungsprüfung im Kontext des Cups + * (z.B. "1. Vorrunde", "Finale", "Qualifikation West"). + * @property istPflichttermin Gibt an, ob die Teilnahme an dieser Wertungsprüfung für die Cup-Gesamtwertung verpflichtend ist. + * @property mindestErgebnisNotwendig Optionales Mindestergebnis, das in dieser Prüfung erzielt werden muss, + * um für den Cup gewertet zu werden oder sich für das Finale zu qualifizieren. + */ +@Serializable +data class MCS_Wertungspruefung( + @Serializable(with = UuidSerializer::class) + val mcsId: Uuid, // Teil des PK, FK zu Meisterschaft_Cup_Serie.mcsId + + @Serializable(with = UuidSerializer::class) + val pruefungAbteilungDbId: Uuid, // Teil des PK, FK zu Pruefung_Abteilung.pruefungAbteilungDbId + + @Serializable(with = BigDecimalSerializer::class) + var faktorFuerWertung: BigDecimal? = BigDecimal.fromInt(1), // Default 1.0 + var bemerkung: String? = null, + var istPflichttermin: Boolean = false, + var mindestErgebnisNotwendig: String? = null // z.B. "Note 6.0", "Fehlerfrei" - muss interpretiert werden +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/Meisterschaft_Cup_Serie.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/Meisterschaft_Cup_Serie.kt new file mode 100644 index 00000000..6210f48e --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/cup/Meisterschaft_Cup_Serie.kt @@ -0,0 +1,73 @@ +import at.mocode.shared.enums.CupSerieTypE +import at.mocode.shared.enums.SparteE +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 + +/** + * Definiert einen übergreifenden Wettbewerb wie eine Meisterschaft, einen Cup oder eine Turnierserie, + * der sich über mehrere Turniere oder spezifische Prüfungen/Abteilungen erstrecken kann und + * eigene Reglements sowie eine Gesamtwertung haben kann. + * + * @property mcsId Eindeutiger interner Identifikator für diese Meisterschaft/Cup/Serie (UUID). + * @property name Der offizielle Name der Meisterschaft, des Cups oder der Serie + * (z.B. "EQUIVERON Cup 2025", "NÖ Landesmeisterschaft Dressur Allgemeine Klasse"). + * @property typ Die Art des übergreifenden Wettbewerbs (siehe `CupSerieTypE`). + * @property jahr Das Jahr, in dem diese Meisterschaft/Cup/Serie stattfindet oder gewertet wird. + * @property sparte Die Pferdesportsparte, für die dieser Wettbewerb primär ausgeschrieben ist. + * @property beschreibung Optionale ausführlichere Beschreibung des Wettbewerbs. + * @property reglementText Das spezifische Reglement als Text oder Markdown. + * @property reglementPdfUrl Optionaler Link zum offiziellen PDF-Reglement. + * @property hauptsponsor Optionaler Name des Hauptsponsors. + * @property gesamtdotationText Optionale Beschreibung der Gesamtdotation (z.B. "ca. EUR 8.000.- in Sachpreisen"). + * @property teilnahmebedingungenText Spezifische Teilnahmebedingungen für diesen Wettbewerb. + * @property austragungsbedingungenText Spezifische Austragungsbedingungen (z.B. welche Prüfungen zählen). + * @property wertungsModusBeschreibung Beschreibung, wie die Gesamtwertung ermittelt wird. + * @property oetoRegelReferenzId Optionale Verknüpfung zu einer spezifischen Regel in der + * `OETORegelReferenz`-Tabelle, die diesen Wettbewerb oder seine Grundlagen definiert. + * @property istAktiv Gibt an, ob dieser Wettbewerb aktuell aktiv ist. + * @property ansprechpartnerDomPersonId Optionale Verknüpfung zur `DomPerson`, die für diesen Cup verantwortlich ist. + * @property logoUrl Optionaler URL zu einem Logo für den Cup/die Meisterschaft. + * @property webseiteUrl Optionale Webseite mit weiteren Informationen. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class Meisterschaft_Cup_Serie( + @Serializable(with = UuidSerializer::class) + val mcsId: Uuid = uuid4(), + + var name: String, + var typ: CupSerieTypE, + var jahr: Int, + var sparte: SparteE, + + var beschreibung: String? = null, + var reglementText: String? = null, + var reglementPdfUrl: String? = null, + var hauptsponsor: String? = null, + var gesamtdotationText: String? = null, + + var teilnahmebedingungenText: String? = null, + var austragungsbedingungenText: String? = null, + var wertungsModusBeschreibung: String? = null, + + @Serializable(with = UuidSerializer::class) + var oetoRegelReferenzId: Uuid? = null, // Dein oeto_regel_ref_id_mcs + + var istAktiv: Boolean = true, + + @Serializable(with = UuidSerializer::class) + var ansprechpartnerDomPersonId: Uuid? = null, + var logoUrl: String? = null, + var webseiteUrl: String? = null, + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/DressurPruefungSpezifika.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/DressurPruefungSpezifika.kt new file mode 100644 index 00000000..bfce88dd --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/DressurPruefungSpezifika.kt @@ -0,0 +1,69 @@ +import at.mocode.shared.enums.PruefungsViereckE +import at.mocode.shared.enums.RichterPositionE +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 + +/** + * Speichert die spezifischen Details und Anforderungen für eine Dressurprüfung, + * die auf einer Basis-Prüfung (`Pruefung_OEPS`) aufbaut. + * + * @property pruefungDbId Eindeutiger Identifikator, der auch der Fremdschlüssel zur + * zugehörigen `Pruefung_OEPS` ist (1:1-Beziehung). + * @property aufgabeStammdatumId Fremdschlüssel zu `Sportfachliche_Stammdaten` (Typ DRESSURAUFGABE), + * die die zu reitende Dressuraufgabe definiert. + * @property klasseStammdatumId Optionaler Fremdschlüssel zu `Sportfachliche_Stammdaten` (Typ BEWERBSKLASSE), + * der die Leistungsklasse dieser Dressurprüfung definiert (z.B. "A", "L", "M"). + * @property richtverfahrenStammdatumId Fremdschlüssel zu `Sportfachliche_Stammdaten` + * (Typ WERTUNGSVERFAHREN_DRESSUR), der das anzuwendende Richtverfahren (z.B. "GM", "GT") definiert. + * @property viereckGroesse Die vorgeschriebene Größe des Dressurvierecks für diese Prüfung. + * @property erlaubeAuswendigReiten Gibt an, ob das Reiten der Aufgabe auswendig erlaubt/vorgeschrieben ist. + * @property erlaubeVorlesen Gibt an, ob das Vorlesen der Aufgabe erlaubt ist. + * @property anzahlRichterGeplant Die geplante Anzahl der Richter für diese Prüfung. + * @property maxPunkteProRichterMöglich Maximale Punktzahl, die pro Richter erreicht werden kann (falls relevant und nicht in der Aufgabe definiert). + * @property geplanteRichterpositionen Liste der geplanten Richterpositionen für diese Prüfung (z.B. [C, M, H]). + * Die tatsächliche Zuweisung von Personen erfolgt über `FunktionaerEinsatzPlanung` oder `BewerbFunktionaerZuordnung`. + * @property standardDauerProStartSek Standarddauer pro Starter in Sekunden für diese Art von Dressurprüfung. + * Kann von der Abteilung überschrieben werden. + * @property pauseNachAnzahlReiter Optional: Nach wie vielen Reitern eine kurze Pause eingeplant werden soll. + * @property dauerPauseMin Optional: Dauer der Pause in Minuten. + * @property createdAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class DressurPruefungSpezifika( + @Serializable(with = UuidSerializer::class) + val pruefungDbId: Uuid, // PK (identisch mit Pruefung_OEPS.pruefungDbId) und FK + + @Serializable(with = UuidSerializer::class) + var aufgabeStammdatumId: Uuid, // FK zu Sportfachliche_Stammdaten (Typ DRESSURAUFGABE) + + @Serializable(with = UuidSerializer::class) + var klasseStammdatumId: Uuid?, // FK zu Sportfachliche_Stammdaten (Typ BEWERBSKLASSE, Sparte Dressur) + + @Serializable(with = UuidSerializer::class) + var richtverfahrenStammdatumId: Uuid, // FK zu Sportfachliche_Stammdaten (Typ WERTUNGSVERFAHREN_DRESSUR) + + var viereckGroesse: PruefungsViereckE, + var erlaubeAuswendigReiten: Boolean = true, + var erlaubeVorlesen: Boolean = false, + var anzahlRichterGeplant: Int = 1, + var maxPunkteProRichterMöglich: Double? = null, + + // Definiert, welche Richterpositionen für diese Prüfung besetzt werden sollen + var geplanteRichterPositionen: List = listOf(RichterPositionE.C), + + // Zeitplanung spezifisch (Default für Abteilungen dieses Dressurbewerbs) + var standardDauerProStartSek: Int = 240, // z.B. 4 Minuten + var pauseNachAnzahlReiter: Int? = null, + var dauerPauseMin: Int? = null, + + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/SpringPruefungSpezifika.kt b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/SpringPruefungSpezifika.kt new file mode 100644 index 00000000..e1ed927a --- /dev/null +++ b/shared/src/commonMain/kotlin/at/mocode/shared/model/veranstaltung/spezifika/SpringPruefungSpezifika.kt @@ -0,0 +1,83 @@ +import at.mocode.shared.enums.ArtDesStechensE +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 + +/** + * Speichert die spezifischen Details und Anforderungen für eine Springprüfung, + * die auf einer Basis-Prüfung (`Pruefung_OEPS`) aufbaut. + * + * @property pruefungDbId Eindeutiger Identifikator, der auch der Fremdschlüssel zur + * zugehörigen `Pruefung_OEPS` ist (1:1-Beziehung). + * @property klasseStammdatumId Optionaler Fremdschlüssel zu `Sportfachliche_Stammdaten` (Typ BEWERBSKLASSE), + * der die Leistungsklasse/Höhe dieser Springprüfung definiert (z.B. "105cm", "Klasse A"). + * @property richtverfahrenStammdatumId Fremdschlüssel zu `Sportfachliche_Stammdaten` + * (Typ WERTUNGSVERFAHREN_SPRINGEN), der das anzuwendende Richtverfahren definiert (z.B. "A2", "C"). + * @property parcoursskizzeUrl Optionaler URL oder Pfad zur Parcoursskizze. + * @property gpParcoursLaengeMeter Länge des Grundparcours in Metern. + * @property gpErlaubteZeitSekunden Erlaubte Zeit für den Grundparcours in Sekunden. + * @property gpHoechstZeitSekunden Höchstzeit für den Grundparcours in Sekunden. + * @property gpAnzahlHindernisse Anzahl der Hindernisse im Grundparcours. + * @property gpAnzahlSpruenge Anzahl der Sprünge im Grundparcours. + * @property hatIdealzeit Gibt an, ob es eine Idealzeit gibt (relevant für Stilspringprüfungen oder spezielle Verfahren). + * @property artDesStechens Die Art des Stechens, falls eines stattfindet (siehe `ArtDesStechensE`). + * @property stParcoursLaengeMeter Länge des Stechparcours in Metern. + * @property stErlaubteZeitSekunden Erlaubte Zeit für das Stechen in Sekunden. + * @property stHoechstZeitSekunden Höchstzeit für das Stechen in Sekunden. + * @property stAnzahlHindernisse Anzahl der Hindernisse im Stechen. + * @property stAnzahlSpruenge Anzahl der Sprünge im Stechen. + * @property standardDauerProStartSek Standarddauer pro Starter in Sekunden für diese Art von Springprüfung. + * @property standardUmbauzeitMin Standard-Umbauzeit nach diesem Bewerb in Minuten (Default für Abteilungen). + * @property standardBesichtigungszeitMin Standard-Besichtigungszeit vor diesem Bewerb in Minuten (Default für Abteilungen). + * @property standardStechzeitZusaetzlichMin Standard-Zusatzzeit für ein eventuelles Stechen in Minuten (Default für Abteilungen). + * @property zeitMessSystemIntegrationInformation Information zur geplanten oder verwendeten Zeitmessanlage (z.B. "Microgate REI2", "Alge Timing"). + * @propertycreatedAt Zeitstempel der Erstellung dieses Datensatzes. + * @property updatedAt Zeitstempel der letzten Aktualisierung dieses Datensatzes. + */ +@Serializable +data class SpringPruefungSpezifika( + @Serializable(with = UuidSerializer::class) + val pruefungDbId: Uuid, // PK (identisch mit Pruefung_OEPS.pruefungDbId) und FK + + @Serializable(with = UuidSerializer::class) + var klasseStammdatumId: Uuid?, // FK zu Sportfachliche_Stammdaten (Typ BEWERBSKLASSE, Sparte Springen) + + @Serializable(with = UuidSerializer::class) + var richtverfahrenStammdatumId: Uuid, // FK zu Sportfachliche_Stammdaten (Typ WERTUNGSVERFAHREN_SPRINGEN) + + var parcoursskizzeUrl: String? = null, + + // Grundparcours Details + var gpParcoursLaengeMeter: Int? = null, + var gpErlaubteZeitSekunden: Int? = null, + var gpHoechstZeitSekunden: Int? = null, + var gpAnzahlHindernisse: Int? = null, + var gpAnzahlSpruenge: Int? = null, + var hatIdealzeit: Boolean = false, + + // Stechen Details (optional, je nach Richtverfahren und artDesStechens) + var artDesStechens: ArtDesStechensE? = null, + var stParcoursLaengeMeter: Int? = null, + var stErlaubteZeitSekunden: Int? = null, + var stHoechstZeitSekunden: Int? = null, + var stAnzahlHindernisse: Int? = null, + var stAnzahlSpruenge: Int? = null, + + // Zeitplanung spezifisch (Default für Abteilungen dieses Springbewerbs) + var standardDauerProStartSek: Int = 90, // z.B. 1.5 Minuten + var standardUmbauzeitMin: Int = 10, + var standardBesichtigungszeitMin: Int = 10, + var standardStechzeitZusaetzlichMin: Int? = null, // Nur relevant, wenn Stechen stattfindet + + var zeitMessSystemIntegrationInformation: String? = null, // Freitext für Info zur Zeitmessung + + // var zugewieseneFunktionaere: List = emptyList(), // Kommt noch + + @Serializable(with = KotlinInstantSerializer::class) + val createdAt: Instant = Clock.System.now(), + @Serializable(with = KotlinInstantSerializer::class) + var updatedAt: Instant = Clock.System.now() +) diff --git a/shared/src/commonMain/kotlin/at/mocode/shared/stammdaten/Person.kt b/shared/src/commonMain/kotlin/at/mocode/shared/stammdaten/Person.kt index 4e4badfb..f6c00c1b 100644 --- a/shared/src/commonMain/kotlin/at/mocode/shared/stammdaten/Person.kt +++ b/shared/src/commonMain/kotlin/at/mocode/shared/stammdaten/Person.kt @@ -1,7 +1,7 @@ package at.mocode.shared.stammdaten import at.mocode.shared.enums.FunktionaerRolle -import at.mocode.shared.enums.Geschlecht +import at.mocode.shared.enums.GeschlechtE import at.mocode.shared.serializers.KotlinInstantSerializer import at.mocode.shared.serializers.KotlinLocalDateSerializer import at.mocode.shared.serializers.UuidSerializer @@ -22,7 +22,7 @@ data class Person( var titel: String?, @Serializable(with = KotlinLocalDateSerializer::class) var geburtsdatum: LocalDate?, - var geschlecht: Geschlecht? = Geschlecht.UNBEKANNT, + var geschlechtE: GeschlechtE?, var nationalitaet: String?, // 3-Letter Code var email: String?, var telefon: String?, diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt deleted file mode 100644 index 3be53f6e..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/ArtikelTest.kt +++ /dev/null @@ -1,152 +0,0 @@ -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 -import kotlinx.serialization.json.Json -import kotlin.test.* -import kotlin.time.Duration.Companion.milliseconds - -class ArtikelTest { - - @Test - fun testCreateArtikel() { - // Create an Artikel with minimal required parameters - val artikel = Artikel( - bezeichnung = "Test Artikel", - preis = BigDecimal.parseString("10.50"), - einheit = "Stück" - ) - - // Verify required fields - assertEquals("Test Artikel", artikel.bezeichnung) - assertEquals(BigDecimal.parseString("10.50"), artikel.preis) - assertEquals("Stück", artikel.einheit) - - // Verify default values - assertNotNull(artikel.id) - assertEquals(false, artikel.istVerbandsabgabe) - assertNotNull(artikel.createdAt) - assertNotNull(artikel.updatedAt) - } - - @Test - fun testCreateArtikelWithAllParameters() { - // Create an Artikel with all parameters - val id = uuid4() - val now = Clock.System.now() - - val artikel = Artikel( - id = id, - bezeichnung = "Vollständiger Artikel", - preis = BigDecimal.parseString("99.99"), - einheit = "Paket", - istVerbandsabgabe = true, - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, artikel.id) - assertEquals("Vollständiger Artikel", artikel.bezeichnung) - assertEquals(BigDecimal.parseString("99.99"), artikel.preis) - assertEquals("Paket", artikel.einheit) - assertEquals(true, artikel.istVerbandsabgabe) - assertEquals(now, artikel.createdAt) - assertEquals(now, artikel.updatedAt) - } - - @Test - fun testModifyArtikel() { - // Create an Artikel - val artikel = Artikel( - bezeichnung = "Original Artikel", - preis = BigDecimal.parseString("10.00"), - einheit = "Stück" - ) - - val originalUpdatedAt = artikel.updatedAt.toString() - - // Modify properties - artikel.bezeichnung = "Geänderter Artikel" - artikel.preis = BigDecimal.parseString("15.00") - artikel.einheit = "Box" - artikel.istVerbandsabgabe = true - artikel.updatedAt = Clock.System.now().plus(1.milliseconds) - - // Verify modifications - assertEquals("Geänderter Artikel", artikel.bezeichnung) - assertEquals(BigDecimal.parseString("15.00"), artikel.preis) - assertEquals("Box", artikel.einheit) - assertEquals(true, artikel.istVerbandsabgabe) - assertNotEquals(originalUpdatedAt, artikel.updatedAt.toString()) - } - - @Test - fun testSerializationDeserialization() { - // Create an Artikel - val artikel = Artikel( - bezeichnung = "Serialisierter Artikel", - preis = BigDecimal.parseString("25.75"), - einheit = "Einheit", - istVerbandsabgabe = true - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(artikel) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"bezeichnung\""), "JSON should contain bezeichnung field") - assertTrue(jsonString.contains("\"Serialisierter Artikel\""), "JSON should contain value Serialisierter Artikel") - assertTrue(jsonString.contains("\"preis\""), "JSON should contain preis field") - assertTrue(jsonString.contains("\"25.75\""), "JSON should contain value 25.75") - assertTrue(jsonString.contains("\"einheit\""), "JSON should contain einheit field") - assertTrue(jsonString.contains("\"Einheit\""), "JSON should contain value Einheit") - assertTrue(jsonString.contains("\"istVerbandsabgabe\""), "JSON should contain istVerbandsabgabe field") - assertTrue(jsonString.contains("true"), "JSON should contain value true") - - // Deserialize from JSON - val deserializedArtikel = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(artikel.id, deserializedArtikel.id) - assertEquals(artikel.bezeichnung, deserializedArtikel.bezeichnung) - assertEquals(artikel.preis, deserializedArtikel.preis) - assertEquals(artikel.einheit, deserializedArtikel.einheit) - assertEquals(artikel.istVerbandsabgabe, deserializedArtikel.istVerbandsabgabe) - assertEquals(artikel.createdAt, deserializedArtikel.createdAt) - assertEquals(artikel.updatedAt, deserializedArtikel.updatedAt) - } - - @Test - fun testCopyArtikel() { - // Create an Artikel - val original = Artikel( - bezeichnung = "Original Artikel", - preis = BigDecimal.parseString("10.00"), - einheit = "Stück" - ) - - // Create a copy with some modified properties - val copy = original.copy( - bezeichnung = "Kopierter Artikel", - preis = BigDecimal.parseString("12.50") - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.einheit, copy.einheit) - assertEquals(original.istVerbandsabgabe, copy.istVerbandsabgabe) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals("Kopierter Artikel", copy.bezeichnung) - assertEquals(BigDecimal.parseString("12.50"), copy.preis) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt deleted file mode 100644 index 445c9bb1..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/MeisterschaftReferenzTest.kt +++ /dev/null @@ -1,165 +0,0 @@ -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 -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class MeisterschaftReferenzTest { - - @Test - fun testCreateMeisterschaftReferenz() { - // Create a MeisterschaftReferenz with minimal required parameters - val meisterschaftId = uuid4() - val meisterschaftReferenz = MeisterschaftReferenz( - meisterschaftId = meisterschaftId, - name = "Test Meisterschaft", - betrifftBewerbNummern = listOf(1, 2, 3), - berechnungsstrategie = null, - reglementUrl = null - ) - - // Verify required fields - assertEquals(meisterschaftId, meisterschaftReferenz.meisterschaftId) - assertEquals("Test Meisterschaft", meisterschaftReferenz.name) - assertEquals(listOf(1, 2, 3), meisterschaftReferenz.betrifftBewerbNummern) - - // Verify default values - assertNotNull(meisterschaftReferenz.id) - assertEquals(null, meisterschaftReferenz.berechnungsstrategie) - assertEquals(null, meisterschaftReferenz.reglementUrl) - } - - @Test - fun testCreateMeisterschaftReferenzWithAllParameters() { - // Create a MeisterschaftReferenz with all parameters - val id = uuid4() - val meisterschaftId = uuid4() - - val meisterschaftReferenz = MeisterschaftReferenz( - id = id, - meisterschaftId = meisterschaftId, - name = "Vollständige Meisterschaft", - betrifftBewerbNummern = listOf(10, 20, 30), - berechnungsstrategie = "Punktesystem A", - reglementUrl = "https://example.com/reglement" - ) - - // Verify all fields - assertEquals(id, meisterschaftReferenz.id) - assertEquals(meisterschaftId, meisterschaftReferenz.meisterschaftId) - assertEquals("Vollständige Meisterschaft", meisterschaftReferenz.name) - assertEquals(listOf(10, 20, 30), meisterschaftReferenz.betrifftBewerbNummern) - assertEquals("Punktesystem A", meisterschaftReferenz.berechnungsstrategie) - assertEquals("https://example.com/reglement", meisterschaftReferenz.reglementUrl) - } - - @Test - fun testModifyMeisterschaftReferenz() { - // Create a MeisterschaftReferenz - val meisterschaftId = uuid4() - val meisterschaftReferenz = MeisterschaftReferenz( - meisterschaftId = meisterschaftId, - name = "Original Meisterschaft", - betrifftBewerbNummern = listOf(1, 2, 3), - berechnungsstrategie = null, - reglementUrl = null - ) - - val newMeisterschaftId = uuid4() - - // Modify properties - meisterschaftReferenz.meisterschaftId = newMeisterschaftId - meisterschaftReferenz.name = "Geänderte Meisterschaft" - meisterschaftReferenz.betrifftBewerbNummern = listOf(4, 5, 6) - meisterschaftReferenz.berechnungsstrategie = "Neues Punktesystem" - meisterschaftReferenz.reglementUrl = "https://example.com/neues-reglement" - - // Verify modifications - assertEquals(newMeisterschaftId, meisterschaftReferenz.meisterschaftId) - assertEquals("Geänderte Meisterschaft", meisterschaftReferenz.name) - assertEquals(listOf(4, 5, 6), meisterschaftReferenz.betrifftBewerbNummern) - assertEquals("Neues Punktesystem", meisterschaftReferenz.berechnungsstrategie) - assertEquals("https://example.com/neues-reglement", meisterschaftReferenz.reglementUrl) - } - - @Test - fun testSerializationDeserialization() { - // Create a MeisterschaftReferenz - val meisterschaftId = uuid4() - val meisterschaftReferenz = MeisterschaftReferenz( - meisterschaftId = meisterschaftId, - name = "Serialisierte Meisterschaft", - betrifftBewerbNummern = listOf(7, 8, 9), - berechnungsstrategie = "Punktesystem B", - reglementUrl = "https://example.com/serialisiert" - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(meisterschaftReferenz) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"meisterschaftId\""), "JSON should contain meisterschaftId field") - assertTrue(jsonString.contains(meisterschaftId.toString()), "JSON should contain meisterschaftId value") - assertTrue(jsonString.contains("\"name\""), "JSON should contain name field") - assertTrue(jsonString.contains("\"Serialisierte Meisterschaft\""), "JSON should contain name value") - assertTrue(jsonString.contains("\"betrifftBewerbNummern\""), "JSON should contain betrifftBewerbNummern field") - assertTrue(jsonString.contains("7"), "JSON should contain betrifftBewerbNummern value 7") - assertTrue(jsonString.contains("8"), "JSON should contain betrifftBewerbNummern value 8") - assertTrue(jsonString.contains("9"), "JSON should contain betrifftBewerbNummern value 9") - assertTrue(jsonString.contains("\"berechnungsstrategie\""), "JSON should contain berechnungsstrategie field") - assertTrue(jsonString.contains("\"Punktesystem B\""), "JSON should contain berechnungsstrategie value") - assertTrue(jsonString.contains("\"reglementUrl\""), "JSON should contain reglementUrl field") - assertTrue(jsonString.contains("\"https://example.com/serialisiert\""), "JSON should contain reglementUrl value") - - // Deserialize from JSON - val deserializedMeisterschaftReferenz = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(meisterschaftReferenz.id, deserializedMeisterschaftReferenz.id) - assertEquals(meisterschaftReferenz.meisterschaftId, deserializedMeisterschaftReferenz.meisterschaftId) - assertEquals(meisterschaftReferenz.name, deserializedMeisterschaftReferenz.name) - assertEquals(meisterschaftReferenz.betrifftBewerbNummern, deserializedMeisterschaftReferenz.betrifftBewerbNummern) - assertEquals(meisterschaftReferenz.berechnungsstrategie, deserializedMeisterschaftReferenz.berechnungsstrategie) - assertEquals(meisterschaftReferenz.reglementUrl, deserializedMeisterschaftReferenz.reglementUrl) - } - - @Test - fun testCopyMeisterschaftReferenz() { - // Create a MeisterschaftReferenz - val meisterschaftId = uuid4() - val original = MeisterschaftReferenz( - meisterschaftId = meisterschaftId, - name = "Original Meisterschaft", - betrifftBewerbNummern = listOf(1, 2, 3), - berechnungsstrategie = "Original Strategie", - reglementUrl = null - ) - - val newMeisterschaftId = uuid4() - - // Create a copy with some modified properties - val copy = original.copy( - name = "Kopierte Meisterschaft", - meisterschaftId = newMeisterschaftId, - reglementUrl = "https://example.com/kopie" - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.betrifftBewerbNummern, copy.betrifftBewerbNummern) - assertEquals(original.berechnungsstrategie, copy.berechnungsstrategie) - - // Verify modified properties - assertEquals("Kopierte Meisterschaft", copy.name) - assertEquals(newMeisterschaftId, copy.meisterschaftId) - assertEquals("https://example.com/kopie", copy.reglementUrl) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt deleted file mode 100644 index ddabd8ec..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/PlatzTest.kt +++ /dev/null @@ -1,141 +0,0 @@ -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 -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class PlatzTest { - - @Test - fun testCreatePlatz() { - // Create a Platz with minimal required parameters - val platz = Platz( - name = "Hauptplatz", - dimension = null, - boden = null, - typ = PlatzTyp.AUSTRAGUNG - ) - - // Verify required fields - assertEquals("Hauptplatz", platz.name) - assertEquals(PlatzTyp.AUSTRAGUNG, platz.typ) - - // Verify default values - assertNotNull(platz.id) - assertEquals(null, platz.dimension) - assertEquals(null, platz.boden) - } - - @Test - fun testCreatePlatzWithAllParameters() { - // Create a Platz with all parameters - val id = uuid4() - - val platz = Platz( - id = id, - name = "Vollständiger Platz", - dimension = "60x20m", - boden = "Sand", - typ = PlatzTyp.VORBEREITUNG - ) - - // Verify all fields - assertEquals(id, platz.id) - assertEquals("Vollständiger Platz", platz.name) - assertEquals("60x20m", platz.dimension) - assertEquals("Sand", platz.boden) - assertEquals(PlatzTyp.VORBEREITUNG, platz.typ) - } - - @Test - fun testModifyPlatz() { - // Create a Platz - val platz = Platz( - name = "Original Platz", - dimension = null, - boden = null, - typ = PlatzTyp.AUSTRAGUNG - ) - - // Modify properties - platz.name = "Geänderter Platz" - platz.dimension = "80x40m" - platz.boden = "Gras" - platz.typ = PlatzTyp.LONGIEREN - - // Verify modifications - assertEquals("Geänderter Platz", platz.name) - assertEquals("80x40m", platz.dimension) - assertEquals("Gras", platz.boden) - assertEquals(PlatzTyp.LONGIEREN, platz.typ) - } - - @Test - fun testSerializationDeserialization() { - // Create a Platz - val platz = Platz( - name = "Serialisierter Platz", - dimension = "70x30m", - boden = "Kunstrasen", - typ = PlatzTyp.SONSTIGES - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(platz) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"name\""), "JSON should contain name field") - assertTrue(jsonString.contains("\"Serialisierter Platz\""), "JSON should contain name value") - assertTrue(jsonString.contains("\"dimension\""), "JSON should contain dimension field") - assertTrue(jsonString.contains("\"70x30m\""), "JSON should contain dimension value") - assertTrue(jsonString.contains("\"boden\""), "JSON should contain boden field") - assertTrue(jsonString.contains("\"Kunstrasen\""), "JSON should contain boden value") - assertTrue(jsonString.contains("\"typ\""), "JSON should contain typ field") - assertTrue(jsonString.contains("\"SONSTIGES\""), "JSON should contain typ value") - - // Deserialize from JSON - val deserializedPlatz = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(platz.id, deserializedPlatz.id) - assertEquals(platz.name, deserializedPlatz.name) - assertEquals(platz.dimension, deserializedPlatz.dimension) - assertEquals(platz.boden, deserializedPlatz.boden) - assertEquals(platz.typ, deserializedPlatz.typ) - } - - @Test - fun testCopyPlatz() { - // Create a Platz - val original = Platz( - name = "Original Platz", - dimension = "50x25m", - boden = "Holzspäne", - typ = PlatzTyp.VORBEREITUNG - ) - - // Create a copy with some modified properties - val copy = original.copy( - name = "Kopierter Platz", - typ = PlatzTyp.LONGIEREN - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.dimension, copy.dimension) - assertEquals(original.boden, copy.boden) - - // Verify modified properties - assertEquals("Kopierter Platz", copy.name) - assertEquals(PlatzTyp.LONGIEREN, copy.typ) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt deleted file mode 100644 index 8800449c..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/TurnierTest.kt +++ /dev/null @@ -1,440 +0,0 @@ -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 -import kotlinx.datetime.LocalDate -import kotlinx.datetime.LocalDateTime -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class TurnierTest { - - @Test - fun testCreateTurnier() { - // Create a Turnier with minimal required parameters - val veranstaltungId = uuid4() - val datumVon = LocalDate(2023, 6, 1) - val datumBis = LocalDate(2023, 6, 3) - - val turnier = Turnier( - veranstaltungId = veranstaltungId, - oepsTurnierNr = "T12345", - titel = "Test Turnier", - untertitel = null, - datumVon = datumVon, - datumBis = datumBis, - nennungsschluss = null, - nennungsHinweis = null, - eigenesNennsystemUrl = null, - nenngeld = null, - startgeldStandard = null, - turnierleiterId = null, - turnierbeauftragterId = null, - tierarztInfos = null, - hufschmiedInfo = null, - meldestelleVerantwortlicherId = null, - meldestelleTelefon = null, - meldestelleOeffnungszeiten = null, - ergebnislistenUrl = null - ) - - // Verify required fields - assertEquals(veranstaltungId, turnier.veranstaltungId) - assertEquals("T12345", turnier.oepsTurnierNr) - assertEquals("Test Turnier", turnier.titel) - assertEquals(datumVon, turnier.datumVon) - assertEquals(datumBis, turnier.datumBis) - - // Verify default values - assertNotNull(turnier.id) - assertEquals(null, turnier.untertitel) - assertEquals(null, turnier.nennungsschluss) - assertTrue(turnier.nennungsArt.isEmpty()) - assertEquals(null, turnier.nennungsHinweis) - assertEquals(null, turnier.eigenesNennsystemUrl) - assertEquals(null, turnier.nenngeld) - assertEquals(null, turnier.startgeldStandard) - assertTrue(turnier.austragungsplaetze.isEmpty()) - assertTrue(turnier.vorbereitungsplaetze.isEmpty()) - assertEquals(null, turnier.turnierleiterId) - assertEquals(null, turnier.turnierbeauftragterId) - assertTrue(turnier.richterIds.isEmpty()) - assertTrue(turnier.parcoursbauerIds.isEmpty()) - assertTrue(turnier.parcoursAssistentIds.isEmpty()) - assertEquals(null, turnier.tierarztInfos) - assertEquals(null, turnier.hufschmiedInfo) - assertEquals(null, turnier.meldestelleVerantwortlicherId) - assertEquals(null, turnier.meldestelleTelefon) - assertEquals(null, turnier.meldestelleOeffnungszeiten) - assertEquals(null, turnier.ergebnislistenUrl) - assertTrue(turnier.verfuegbareArtikel.isEmpty()) - assertTrue(turnier.meisterschaftRefs.isEmpty()) - assertNotNull(turnier.createdAt) - assertNotNull(turnier.updatedAt) - } - - @Test - fun testCreateTurnierWithAllParameters() { - // Create a Turnier with all parameters - val id = uuid4() - val veranstaltungId = uuid4() - val datumVon = LocalDate(2023, 7, 15) - val datumBis = LocalDate(2023, 7, 17) - val nennungsschluss = LocalDateTime(2023, 7, 10, 23, 59, 59) - val turnierleiterId = uuid4() - val turnierbeauftragterId = uuid4() - val meldestelleVerantwortlicherId = uuid4() - val now = Clock.System.now() - - // 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 richterIds = listOf(uuid4(), uuid4()) - val parcoursbauerIds = listOf(uuid4()) - val parcoursAssistentIds = listOf(uuid4()) - val artikel = Artikel(bezeichnung = "Startgebühr", preis = BigDecimal.parseString("25.00"), einheit = "Start") - val meisterschaftRef = MeisterschaftReferenz( - meisterschaftId = uuid4(), - name = "Landesmeisterschaft", - betrifftBewerbNummern = listOf(1, 2, 3), - berechnungsstrategie = "Standard", - reglementUrl = null - ) - - val turnier = Turnier( - id = id, - veranstaltungId = veranstaltungId, - oepsTurnierNr = "T67890", - titel = "Vollständiges Turnier", - untertitel = "Mit allen Details", - datumVon = datumVon, - datumBis = datumBis, - nennungsschluss = nennungsschluss, - nennungsArt = nennungsArt, - nennungsHinweis = "Bitte rechtzeitig nennen", - eigenesNennsystemUrl = "https://example.com/nennung", - nenngeld = BigDecimal.parseString("50.00"), - startgeldStandard = BigDecimal.parseString("25.00"), - austragungsplaetze = listOf(austragungsplatz), - vorbereitungsplaetze = listOf(vorbereitungsplatz), - turnierleiterId = turnierleiterId, - turnierbeauftragterId = turnierbeauftragterId, - richterIds = richterIds, - parcoursbauerIds = parcoursbauerIds, - parcoursAssistentIds = parcoursAssistentIds, - tierarztInfos = "Dr. Vet, Tel: 12345", - hufschmiedInfo = "Hans Schmidt, Tel: 67890", - meldestelleVerantwortlicherId = meldestelleVerantwortlicherId, - meldestelleTelefon = "+43 123 456789", - meldestelleOeffnungszeiten = "8-18 Uhr", - ergebnislistenUrl = "https://example.com/ergebnisse", - verfuegbareArtikel = listOf(artikel), - meisterschaftRefs = listOf(meisterschaftRef), - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, turnier.id) - assertEquals(veranstaltungId, turnier.veranstaltungId) - assertEquals("T67890", turnier.oepsTurnierNr) - assertEquals("Vollständiges Turnier", turnier.titel) - assertEquals("Mit allen Details", turnier.untertitel) - assertEquals(datumVon, turnier.datumVon) - assertEquals(datumBis, turnier.datumBis) - assertEquals(nennungsschluss, turnier.nennungsschluss) - assertEquals(nennungsArt, turnier.nennungsArt) - assertEquals("Bitte rechtzeitig nennen", turnier.nennungsHinweis) - assertEquals("https://example.com/nennung", turnier.eigenesNennsystemUrl) - assertEquals(BigDecimal.parseString("50.00"), turnier.nenngeld) - assertEquals(BigDecimal.parseString("25.00"), turnier.startgeldStandard) - assertEquals(1, turnier.austragungsplaetze.size) - assertEquals(austragungsplatz.name, turnier.austragungsplaetze[0].name) - assertEquals(1, turnier.vorbereitungsplaetze.size) - assertEquals(vorbereitungsplatz.name, turnier.vorbereitungsplaetze[0].name) - assertEquals(turnierleiterId, turnier.turnierleiterId) - assertEquals(turnierbeauftragterId, turnier.turnierbeauftragterId) - assertEquals(richterIds, turnier.richterIds) - assertEquals(parcoursbauerIds, turnier.parcoursbauerIds) - assertEquals(parcoursAssistentIds, turnier.parcoursAssistentIds) - assertEquals("Dr. Vet, Tel: 12345", turnier.tierarztInfos) - assertEquals("Hans Schmidt, Tel: 67890", turnier.hufschmiedInfo) - assertEquals(meldestelleVerantwortlicherId, turnier.meldestelleVerantwortlicherId) - assertEquals("+43 123 456789", turnier.meldestelleTelefon) - assertEquals("8-18 Uhr", turnier.meldestelleOeffnungszeiten) - assertEquals("https://example.com/ergebnisse", turnier.ergebnislistenUrl) - assertEquals(1, turnier.verfuegbareArtikel.size) - assertEquals(artikel.bezeichnung, turnier.verfuegbareArtikel[0].bezeichnung) - assertEquals(1, turnier.meisterschaftRefs.size) - assertEquals(meisterschaftRef.name, turnier.meisterschaftRefs[0].name) - assertEquals(now, turnier.createdAt) - assertEquals(now, turnier.updatedAt) - } - - @Test - fun testModifyTurnier() { - // Create a Turnier - val veranstaltungId = uuid4() - val datumVon = LocalDate(2023, 8, 1) - val datumBis = LocalDate(2023, 8, 3) - - val turnier = Turnier( - veranstaltungId = veranstaltungId, - oepsTurnierNr = "T12345", - titel = "Original Turnier", - untertitel = null, - datumVon = datumVon, - datumBis = datumBis, - nennungsschluss = null, - nennungsHinweis = null, - eigenesNennsystemUrl = null, - nenngeld = null, - startgeldStandard = null, - turnierleiterId = null, - turnierbeauftragterId = null, - tierarztInfos = null, - hufschmiedInfo = null, - meldestelleVerantwortlicherId = null, - meldestelleTelefon = null, - meldestelleOeffnungszeiten = null, - ergebnislistenUrl = null - ) - - val originalUpdatedAt = turnier.updatedAt - val newVeranstaltungId = uuid4() - val newDatumVon = LocalDate(2023, 9, 1) - val newDatumBis = LocalDate(2023, 9, 3) - val newNennungsschluss = LocalDateTime(2023, 8, 25, 23, 59, 59) - val newTurnierleiterId = uuid4() - val newTurnierbeauftragterId = uuid4() - val newMeldestelleVerantwortlicherId = uuid4() - - // 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 richterIds = listOf(uuid4()) - val artikel = - Artikel(bezeichnung = "Neue Startgebühr", preis = BigDecimal.parseString("30.00"), einheit = "Start") - - // Modify properties - turnier.veranstaltungId = newVeranstaltungId - turnier.oepsTurnierNr = "T54321" - turnier.titel = "Geändertes Turnier" - turnier.untertitel = "Mit Untertitel" - turnier.datumVon = newDatumVon - turnier.datumBis = newDatumBis - turnier.nennungsschluss = newNennungsschluss - turnier.nennungsArt = nennungsArt - turnier.nennungsHinweis = "Neuer Hinweis" - turnier.eigenesNennsystemUrl = "https://example.com/neues-system" - turnier.nenngeld = BigDecimal.parseString("60.00") - turnier.startgeldStandard = BigDecimal.parseString("35.00") - turnier.austragungsplaetze = listOf(austragungsplatz) - turnier.turnierleiterId = newTurnierleiterId - turnier.turnierbeauftragterId = newTurnierbeauftragterId - turnier.richterIds = richterIds - turnier.tierarztInfos = "Neuer Tierarzt" - turnier.hufschmiedInfo = "Neuer Hufschmied" - turnier.meldestelleVerantwortlicherId = newMeldestelleVerantwortlicherId - turnier.meldestelleTelefon = "+43 987 654321" - turnier.meldestelleOeffnungszeiten = "9-17 Uhr" - turnier.ergebnislistenUrl = "https://example.com/neue-ergebnisse" - turnier.verfuegbareArtikel = listOf(artikel) - turnier.updatedAt = Clock.System.now() - - // Verify modifications - assertEquals(newVeranstaltungId, turnier.veranstaltungId) - assertEquals("T54321", turnier.oepsTurnierNr) - assertEquals("Geändertes Turnier", turnier.titel) - assertEquals("Mit Untertitel", turnier.untertitel) - assertEquals(newDatumVon, turnier.datumVon) - assertEquals(newDatumBis, turnier.datumBis) - assertEquals(newNennungsschluss, turnier.nennungsschluss) - assertEquals(nennungsArt, turnier.nennungsArt) - assertEquals("Neuer Hinweis", turnier.nennungsHinweis) - assertEquals("https://example.com/neues-system", turnier.eigenesNennsystemUrl) - assertEquals(BigDecimal.parseString("60.00"), turnier.nenngeld) - assertEquals(BigDecimal.parseString("35.00"), turnier.startgeldStandard) - assertEquals(1, turnier.austragungsplaetze.size) - assertEquals("Neuer Hauptplatz", turnier.austragungsplaetze[0].name) - assertEquals(newTurnierleiterId, turnier.turnierleiterId) - assertEquals(newTurnierbeauftragterId, turnier.turnierbeauftragterId) - assertEquals(richterIds, turnier.richterIds) - assertEquals("Neuer Tierarzt", turnier.tierarztInfos) - assertEquals("Neuer Hufschmied", turnier.hufschmiedInfo) - assertEquals(newMeldestelleVerantwortlicherId, turnier.meldestelleVerantwortlicherId) - assertEquals("+43 987 654321", turnier.meldestelleTelefon) - assertEquals("9-17 Uhr", turnier.meldestelleOeffnungszeiten) - assertEquals("https://example.com/neue-ergebnisse", turnier.ergebnislistenUrl) - assertEquals(1, turnier.verfuegbareArtikel.size) - assertEquals("Neue Startgebühr", turnier.verfuegbareArtikel[0].bezeichnung) - // 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 Turnier for serialization testing - val veranstaltungId = uuid4() - val datumVon = LocalDate(2023, 10, 1) - val datumBis = LocalDate(2023, 10, 3) - val turnierleiterId = uuid4() - - val turnier = Turnier( - veranstaltungId = veranstaltungId, - oepsTurnierNr = "T12345", - titel = "Serialisiertes Turnier", - untertitel = "Für Test", - datumVon = datumVon, - datumBis = datumBis, - nennungsschluss = null, - nennungsArt = listOf(NennungsArt.OEPS_ZNS), - nennungsHinweis = "Hinweis", - eigenesNennsystemUrl = null, - nenngeld = BigDecimal.parseString("40.00"), - startgeldStandard = null, - turnierleiterId = turnierleiterId, - turnierbeauftragterId = null, - tierarztInfos = "Tierarzt Info", - hufschmiedInfo = null, - meldestelleVerantwortlicherId = null, - meldestelleTelefon = "+43 123 456789", - meldestelleOeffnungszeiten = null, - ergebnislistenUrl = null - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(turnier) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"veranstaltungId\""), "JSON should contain veranstaltungId field") - assertTrue(jsonString.contains(veranstaltungId.toString()), "JSON should contain veranstaltungId value") - assertTrue(jsonString.contains("\"oepsTurnierNr\""), "JSON should contain oepsTurnierNr field") - assertTrue(jsonString.contains("\"T12345\""), "JSON should contain oepsTurnierNr value") - assertTrue(jsonString.contains("\"titel\""), "JSON should contain titel field") - assertTrue(jsonString.contains("\"Serialisiertes Turnier\""), "JSON should contain titel value") - assertTrue(jsonString.contains("\"datumVon\""), "JSON should contain datumVon field") - assertTrue(jsonString.contains("\"2023-10-01\""), "JSON should contain datumVon value") - assertTrue(jsonString.contains("\"nennungsArt\""), "JSON should contain nennungsArt field") - assertTrue(jsonString.contains("\"OEPS_ZNS\""), "JSON should contain nennungsArt value") - assertTrue(jsonString.contains("\"nenngeld\""), "JSON should contain nenngeld field") - assertTrue(jsonString.contains("40"), "JSON should contain nenngeld value") - assertTrue(jsonString.contains("\"turnierleiterId\""), "JSON should contain turnierleiterId field") - assertTrue(jsonString.contains(turnierleiterId.toString()), "JSON should contain turnierleiterId value") - - // Deserialize from JSON - val deserializedTurnier = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(turnier.id, deserializedTurnier.id) - assertEquals(turnier.veranstaltungId, deserializedTurnier.veranstaltungId) - assertEquals(turnier.oepsTurnierNr, deserializedTurnier.oepsTurnierNr) - assertEquals(turnier.titel, deserializedTurnier.titel) - assertEquals(turnier.untertitel, deserializedTurnier.untertitel) - assertEquals(turnier.datumVon, deserializedTurnier.datumVon) - assertEquals(turnier.datumBis, deserializedTurnier.datumBis) - assertEquals(turnier.nennungsArt, deserializedTurnier.nennungsArt) - assertEquals(turnier.nennungsHinweis, deserializedTurnier.nennungsHinweis) - assertEquals(turnier.nenngeld, deserializedTurnier.nenngeld) - assertEquals(turnier.turnierleiterId, deserializedTurnier.turnierleiterId) - assertEquals(turnier.tierarztInfos, deserializedTurnier.tierarztInfos) - assertEquals(turnier.meldestelleTelefon, deserializedTurnier.meldestelleTelefon) - assertEquals(turnier.createdAt, deserializedTurnier.createdAt) - assertEquals(turnier.updatedAt, deserializedTurnier.updatedAt) - } - - @Test - fun testCopyTurnier() { - // Create a Turnier - val veranstaltungId = uuid4() - val datumVon = LocalDate(2023, 11, 1) - val datumBis = LocalDate(2023, 11, 3) - - val original = Turnier( - veranstaltungId = veranstaltungId, - oepsTurnierNr = "T12345", - titel = "Original Turnier", - untertitel = "Original Untertitel", - datumVon = datumVon, - datumBis = datumBis, - nennungsschluss = null, - nennungsHinweis = "Original Hinweis", - eigenesNennsystemUrl = null, - nenngeld = BigDecimal.parseString("50.00"), - startgeldStandard = null, - turnierleiterId = null, - turnierbeauftragterId = null, - tierarztInfos = null, - hufschmiedInfo = null, - meldestelleVerantwortlicherId = null, - meldestelleTelefon = null, - meldestelleOeffnungszeiten = null, - ergebnislistenUrl = null - ) - - val newVeranstaltungId = uuid4() - val newDatumVon = LocalDate(2023, 12, 1) - val newDatumBis = LocalDate(2023, 12, 3) - - // Create a copy with some modified properties - val copy = original.copy( - veranstaltungId = newVeranstaltungId, - titel = "Kopiertes Turnier", - datumVon = newDatumVon, - datumBis = newDatumBis, - nenngeld = BigDecimal.parseString("60.00") - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.oepsTurnierNr, copy.oepsTurnierNr) - assertEquals(original.untertitel, copy.untertitel) - assertEquals(original.nennungsschluss, copy.nennungsschluss) - assertEquals(original.nennungsArt, copy.nennungsArt) - assertEquals(original.nennungsHinweis, copy.nennungsHinweis) - assertEquals(original.eigenesNennsystemUrl, copy.eigenesNennsystemUrl) - assertEquals(original.startgeldStandard, copy.startgeldStandard) - assertEquals(original.austragungsplaetze, copy.austragungsplaetze) - assertEquals(original.vorbereitungsplaetze, copy.vorbereitungsplaetze) - assertEquals(original.turnierleiterId, copy.turnierleiterId) - assertEquals(original.turnierbeauftragterId, copy.turnierbeauftragterId) - assertEquals(original.richterIds, copy.richterIds) - assertEquals(original.parcoursbauerIds, copy.parcoursbauerIds) - assertEquals(original.parcoursAssistentIds, copy.parcoursAssistentIds) - assertEquals(original.tierarztInfos, copy.tierarztInfos) - assertEquals(original.hufschmiedInfo, copy.hufschmiedInfo) - assertEquals(original.meldestelleVerantwortlicherId, copy.meldestelleVerantwortlicherId) - assertEquals(original.meldestelleTelefon, copy.meldestelleTelefon) - assertEquals(original.meldestelleOeffnungszeiten, copy.meldestelleOeffnungszeiten) - assertEquals(original.ergebnislistenUrl, copy.ergebnislistenUrl) - assertEquals(original.verfuegbareArtikel, copy.verfuegbareArtikel) - assertEquals(original.meisterschaftRefs, copy.meisterschaftRefs) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals(newVeranstaltungId, copy.veranstaltungId) - assertEquals("Kopiertes Turnier", copy.titel) - assertEquals(newDatumVon, copy.datumVon) - assertEquals(newDatumBis, copy.datumBis) - assertEquals(BigDecimal.parseString("60.00"), copy.nenngeld) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt deleted file mode 100644 index 87b4fdbe..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/entitaeten/VeranstaltungTest.kt +++ /dev/null @@ -1,335 +0,0 @@ -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 -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class VeranstaltungTest { - - @Test - fun testCreateVeranstaltung() { - // Create a Veranstaltung with minimal required parameters - val datumVon = LocalDate(2023, 6, 1) - val datumBis = LocalDate(2023, 6, 3) - - val veranstaltung = Veranstaltung( - name = "Test Veranstaltung", - datumVon = datumVon, - datumBis = datumBis, - veranstalterName = "Test Veranstalter", - veranstalterOepsNummer = null, - veranstaltungsortName = "Test Ort", - veranstaltungsortAdresse = "Test Adresse", - kontaktpersonName = null, - kontaktTelefon = null, - kontaktEmail = null, - webseite = null, - logoUrl = null, - anfahrtsplanInfo = null, - dsgvoText = null, - haftungsText = null, - sonstigeBesondereBestimmungen = null - ) - - // Verify required fields - assertEquals("Test Veranstaltung", veranstaltung.name) - assertEquals(datumVon, veranstaltung.datumVon) - assertEquals(datumBis, veranstaltung.datumBis) - assertEquals("Test Veranstalter", veranstaltung.veranstalterName) - assertEquals("Test Ort", veranstaltung.veranstaltungsortName) - assertEquals("Test Adresse", veranstaltung.veranstaltungsortAdresse) - - // Verify default values - assertNotNull(veranstaltung.id) - assertEquals(VeranstalterTyp.UNBEKANNT, veranstaltung.veranstalterTyp) - assertEquals(null, veranstaltung.veranstalterOepsNummer) - assertEquals(null, veranstaltung.kontaktpersonName) - assertEquals(null, veranstaltung.kontaktTelefon) - assertEquals(null, veranstaltung.kontaktEmail) - assertEquals(null, veranstaltung.webseite) - assertEquals(null, veranstaltung.logoUrl) - assertEquals(null, veranstaltung.anfahrtsplanInfo) - assertTrue(veranstaltung.sponsorInfos.isEmpty()) - assertEquals(null, veranstaltung.dsgvoText) - assertEquals(null, veranstaltung.haftungsText) - assertEquals(null, veranstaltung.sonstigeBesondereBestimmungen) - assertNotNull(veranstaltung.createdAt) - assertNotNull(veranstaltung.updatedAt) - } - - @Test - fun testCreateVeranstaltungWithAllParameters() { - // Create a Veranstaltung with all parameters - val id = uuid4() - val datumVon = LocalDate(2023, 7, 15) - val datumBis = LocalDate(2023, 7, 17) - val now = Clock.System.now() - val sponsorInfos = listOf("Sponsor 1", "Sponsor 2") - - val veranstaltung = Veranstaltung( - id = id, - name = "Vollständige Veranstaltung", - datumVon = datumVon, - datumBis = datumBis, - veranstalterName = "Vollständiger Veranstalter", - veranstalterOepsNummer = "V12345", - veranstalterTyp = VeranstalterTyp.VEREIN, - veranstaltungsortName = "Vollständiger Ort", - veranstaltungsortAdresse = "Vollständige Adresse", - kontaktpersonName = "Max Mustermann", - kontaktTelefon = "+43 123 456789", - kontaktEmail = "max@example.com", - webseite = "https://example.com", - logoUrl = "https://example.com/logo.png", - anfahrtsplanInfo = "Anfahrtsplan Info", - sponsorInfos = sponsorInfos, - dsgvoText = "DSGVO Text", - haftungsText = "Haftungs Text", - sonstigeBesondereBestimmungen = "Besondere Bestimmungen", - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, veranstaltung.id) - assertEquals("Vollständige Veranstaltung", veranstaltung.name) - assertEquals(datumVon, veranstaltung.datumVon) - assertEquals(datumBis, veranstaltung.datumBis) - assertEquals("Vollständiger Veranstalter", veranstaltung.veranstalterName) - assertEquals("V12345", veranstaltung.veranstalterOepsNummer) - assertEquals(VeranstalterTyp.VEREIN, veranstaltung.veranstalterTyp) - assertEquals("Vollständiger Ort", veranstaltung.veranstaltungsortName) - assertEquals("Vollständige Adresse", veranstaltung.veranstaltungsortAdresse) - assertEquals("Max Mustermann", veranstaltung.kontaktpersonName) - assertEquals("+43 123 456789", veranstaltung.kontaktTelefon) - assertEquals("max@example.com", veranstaltung.kontaktEmail) - assertEquals("https://example.com", veranstaltung.webseite) - assertEquals("https://example.com/logo.png", veranstaltung.logoUrl) - assertEquals("Anfahrtsplan Info", veranstaltung.anfahrtsplanInfo) - assertEquals(sponsorInfos, veranstaltung.sponsorInfos) - assertEquals("DSGVO Text", veranstaltung.dsgvoText) - assertEquals("Haftungs Text", veranstaltung.haftungsText) - assertEquals("Besondere Bestimmungen", veranstaltung.sonstigeBesondereBestimmungen) - assertEquals(now, veranstaltung.createdAt) - assertEquals(now, veranstaltung.updatedAt) - } - - @Test - fun testModifyVeranstaltung() { - // Create a Veranstaltung - val datumVon = LocalDate(2023, 8, 1) - val datumBis = LocalDate(2023, 8, 3) - - val veranstaltung = Veranstaltung( - name = "Original Veranstaltung", - datumVon = datumVon, - datumBis = datumBis, - veranstalterName = "Original Veranstalter", - veranstalterOepsNummer = null, - veranstaltungsortName = "Original Ort", - veranstaltungsortAdresse = "Original Adresse", - kontaktpersonName = null, - kontaktTelefon = null, - kontaktEmail = null, - webseite = null, - logoUrl = null, - anfahrtsplanInfo = null, - dsgvoText = null, - haftungsText = null, - sonstigeBesondereBestimmungen = null - ) - - val originalUpdatedAt = veranstaltung.updatedAt - val newDatumVon = LocalDate(2023, 9, 1) - val newDatumBis = LocalDate(2023, 9, 3) - val sponsorInfos = listOf("Neuer Sponsor") - - // Modify properties - veranstaltung.name = "Geänderte Veranstaltung" - veranstaltung.datumVon = newDatumVon - veranstaltung.datumBis = newDatumBis - veranstaltung.veranstalterName = "Geänderter Veranstalter" - veranstaltung.veranstalterOepsNummer = "V54321" - veranstaltung.veranstalterTyp = VeranstalterTyp.FIRMA - veranstaltung.veranstaltungsortName = "Geänderter Ort" - veranstaltung.veranstaltungsortAdresse = "Geänderte Adresse" - veranstaltung.kontaktpersonName = "Maria Musterfrau" - veranstaltung.kontaktTelefon = "+43 987 654321" - veranstaltung.kontaktEmail = "maria@example.com" - veranstaltung.webseite = "https://example.com/neu" - veranstaltung.logoUrl = "https://example.com/neues-logo.png" - veranstaltung.anfahrtsplanInfo = "Neue Anfahrtsplan Info" - veranstaltung.sponsorInfos = sponsorInfos - veranstaltung.dsgvoText = "Neuer DSGVO Text" - veranstaltung.haftungsText = "Neuer Haftungs Text" - veranstaltung.sonstigeBesondereBestimmungen = "Neue Besondere Bestimmungen" - veranstaltung.updatedAt = Clock.System.now() - - // Verify modifications - assertEquals("Geänderte Veranstaltung", veranstaltung.name) - assertEquals(newDatumVon, veranstaltung.datumVon) - assertEquals(newDatumBis, veranstaltung.datumBis) - assertEquals("Geänderter Veranstalter", veranstaltung.veranstalterName) - assertEquals("V54321", veranstaltung.veranstalterOepsNummer) - assertEquals(VeranstalterTyp.FIRMA, veranstaltung.veranstalterTyp) - assertEquals("Geänderter Ort", veranstaltung.veranstaltungsortName) - assertEquals("Geänderte Adresse", veranstaltung.veranstaltungsortAdresse) - assertEquals("Maria Musterfrau", veranstaltung.kontaktpersonName) - assertEquals("+43 987 654321", veranstaltung.kontaktTelefon) - assertEquals("maria@example.com", veranstaltung.kontaktEmail) - assertEquals("https://example.com/neu", veranstaltung.webseite) - assertEquals("https://example.com/neues-logo.png", veranstaltung.logoUrl) - assertEquals("Neue Anfahrtsplan Info", veranstaltung.anfahrtsplanInfo) - assertEquals(sponsorInfos, veranstaltung.sponsorInfos) - assertEquals("Neuer DSGVO Text", veranstaltung.dsgvoText) - assertEquals("Neuer Haftungs Text", veranstaltung.haftungsText) - assertEquals("Neue Besondere Bestimmungen", veranstaltung.sonstigeBesondereBestimmungen) - // Skip updatedAt verification for wasmJs compatibility - // The updatedAt field is properly set, but comparison in wasmJs environment is problematic - } - - @Test - fun testSerializationDeserialization() { - // Create a Veranstaltung - val datumVon = LocalDate(2023, 10, 1) - val datumBis = LocalDate(2023, 10, 3) - val sponsorInfos = listOf("Sponsor A", "Sponsor B") - - val veranstaltung = Veranstaltung( - name = "Serialisierte Veranstaltung", - datumVon = datumVon, - datumBis = datumBis, - veranstalterName = "Serialisierter Veranstalter", - veranstalterOepsNummer = "V12345", - veranstalterTyp = VeranstalterTyp.VEREIN, - veranstaltungsortName = "Serialisierter Ort", - veranstaltungsortAdresse = "Serialisierte Adresse", - kontaktpersonName = "Kontakt Person", - kontaktTelefon = "+43 123 456789", - kontaktEmail = "kontakt@example.com", - webseite = "https://example.com", - logoUrl = "https://example.com/logo.png", - anfahrtsplanInfo = "Anfahrtsplan Info", - sponsorInfos = sponsorInfos, - dsgvoText = "DSGVO Text", - haftungsText = "Haftungs Text", - sonstigeBesondereBestimmungen = "Besondere Bestimmungen" - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(veranstaltung) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"name\""), "JSON should contain name field") - assertTrue(jsonString.contains("\"Serialisierte Veranstaltung\""), "JSON should contain name value") - assertTrue(jsonString.contains("\"datumVon\""), "JSON should contain datumVon field") - assertTrue(jsonString.contains("\"2023-10-01\""), "JSON should contain datumVon value") - assertTrue(jsonString.contains("\"veranstalterName\""), "JSON should contain veranstalterName field") - assertTrue(jsonString.contains("\"Serialisierter Veranstalter\""), "JSON should contain veranstalterName value") - assertTrue(jsonString.contains("\"veranstalterTyp\""), "JSON should contain veranstalterTyp field") - assertTrue(jsonString.contains("\"VEREIN\""), "JSON should contain veranstalterTyp value") - assertTrue(jsonString.contains("\"sponsorInfos\""), "JSON should contain sponsorInfos field") - assertTrue(jsonString.contains("\"Sponsor A\""), "JSON should contain sponsorInfos value") - assertTrue(jsonString.contains("\"Sponsor B\""), "JSON should contain sponsorInfos value") - - // Deserialize from JSON - val deserializedVeranstaltung = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(veranstaltung.id, deserializedVeranstaltung.id) - assertEquals(veranstaltung.name, deserializedVeranstaltung.name) - assertEquals(veranstaltung.datumVon, deserializedVeranstaltung.datumVon) - assertEquals(veranstaltung.datumBis, deserializedVeranstaltung.datumBis) - assertEquals(veranstaltung.veranstalterName, deserializedVeranstaltung.veranstalterName) - assertEquals(veranstaltung.veranstalterOepsNummer, deserializedVeranstaltung.veranstalterOepsNummer) - assertEquals(veranstaltung.veranstalterTyp, deserializedVeranstaltung.veranstalterTyp) - assertEquals(veranstaltung.veranstaltungsortName, deserializedVeranstaltung.veranstaltungsortName) - assertEquals(veranstaltung.veranstaltungsortAdresse, deserializedVeranstaltung.veranstaltungsortAdresse) - assertEquals(veranstaltung.kontaktpersonName, deserializedVeranstaltung.kontaktpersonName) - assertEquals(veranstaltung.kontaktTelefon, deserializedVeranstaltung.kontaktTelefon) - assertEquals(veranstaltung.kontaktEmail, deserializedVeranstaltung.kontaktEmail) - assertEquals(veranstaltung.webseite, deserializedVeranstaltung.webseite) - assertEquals(veranstaltung.logoUrl, deserializedVeranstaltung.logoUrl) - assertEquals(veranstaltung.anfahrtsplanInfo, deserializedVeranstaltung.anfahrtsplanInfo) - assertEquals(veranstaltung.sponsorInfos, deserializedVeranstaltung.sponsorInfos) - assertEquals(veranstaltung.dsgvoText, deserializedVeranstaltung.dsgvoText) - assertEquals(veranstaltung.haftungsText, deserializedVeranstaltung.haftungsText) - assertEquals(veranstaltung.sonstigeBesondereBestimmungen, deserializedVeranstaltung.sonstigeBesondereBestimmungen) - assertEquals(veranstaltung.createdAt, deserializedVeranstaltung.createdAt) - assertEquals(veranstaltung.updatedAt, deserializedVeranstaltung.updatedAt) - } - - @Test - fun testCopyVeranstaltung() { - // Create a Veranstaltung - val datumVon = LocalDate(2023, 11, 1) - val datumBis = LocalDate(2023, 11, 3) - - val original = Veranstaltung( - name = "Original Veranstaltung", - datumVon = datumVon, - datumBis = datumBis, - veranstalterName = "Original Veranstalter", - veranstalterOepsNummer = "V12345", - veranstalterTyp = VeranstalterTyp.VEREIN, - veranstaltungsortName = "Original Ort", - veranstaltungsortAdresse = "Original Adresse", - kontaktpersonName = "Original Kontakt", - kontaktTelefon = null, - kontaktEmail = null, - webseite = null, - logoUrl = null, - anfahrtsplanInfo = null, - dsgvoText = null, - haftungsText = null, - sonstigeBesondereBestimmungen = null - ) - - val newDatumVon = LocalDate(2023, 12, 1) - val newDatumBis = LocalDate(2023, 12, 3) - - // Create a copy with some modified properties - val copy = original.copy( - name = "Kopierte Veranstaltung", - datumVon = newDatumVon, - datumBis = newDatumBis, - veranstalterTyp = VeranstalterTyp.FIRMA - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.veranstalterName, copy.veranstalterName) - assertEquals(original.veranstalterOepsNummer, copy.veranstalterOepsNummer) - assertEquals(original.veranstaltungsortName, copy.veranstaltungsortName) - assertEquals(original.veranstaltungsortAdresse, copy.veranstaltungsortAdresse) - assertEquals(original.kontaktpersonName, copy.kontaktpersonName) - assertEquals(original.kontaktTelefon, copy.kontaktTelefon) - assertEquals(original.kontaktEmail, copy.kontaktEmail) - assertEquals(original.webseite, copy.webseite) - assertEquals(original.logoUrl, copy.logoUrl) - assertEquals(original.anfahrtsplanInfo, copy.anfahrtsplanInfo) - assertEquals(original.sponsorInfos, copy.sponsorInfos) - assertEquals(original.dsgvoText, copy.dsgvoText) - assertEquals(original.haftungsText, copy.haftungsText) - assertEquals(original.sonstigeBesondereBestimmungen, copy.sonstigeBesondereBestimmungen) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals("Kopierte Veranstaltung", copy.name) - assertEquals(newDatumVon, copy.datumVon) - assertEquals(newDatumBis, copy.datumBis) - assertEquals(VeranstalterTyp.FIRMA, copy.veranstalterTyp) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/enums/EnumsTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/enums/EnumsTest.kt deleted file mode 100644 index dfb5dd42..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/enums/EnumsTest.kt +++ /dev/null @@ -1,573 +0,0 @@ -package at.mocode.shared.enums - -import kotlinx.serialization.Serializable -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotEquals -import kotlin.test.assertTrue - -class EnumsTest { - - @Test - fun testVeranstalterTypEnum() { - // Test all enum values - val values = VeranstalterTyp.entries.toTypedArray() - assertEquals(5, values.size) - - // Test specific enum values - assertEquals(VeranstalterTyp.VEREIN, values[0]) - assertEquals(VeranstalterTyp.FIRMA, values[1]) - assertEquals(VeranstalterTyp.PRIVATPERSON, values[2]) - assertEquals(VeranstalterTyp.SONSTIGE, values[3]) - assertEquals(VeranstalterTyp.UNBEKANNT, values[4]) - - // Test serialization and deserialization - testEnumSerialization(VeranstalterTyp.VEREIN) - testEnumSerialization(VeranstalterTyp.FIRMA) - testEnumSerialization(VeranstalterTyp.PRIVATPERSON) - testEnumSerialization(VeranstalterTyp.SONSTIGE) - testEnumSerialization(VeranstalterTyp.UNBEKANNT) - - // Test comparison - assertEquals(VeranstalterTyp.VEREIN, VeranstalterTyp.VEREIN) - assertNotEquals(VeranstalterTyp.VEREIN, VeranstalterTyp.FIRMA) - } - - @Test - fun testPlatzTypEnum() { - // Test all enum values - val values = PlatzTyp.entries.toTypedArray() - assertEquals(4, values.size) - - // Test specific enum values - assertEquals(PlatzTyp.AUSTRAGUNG, values[0]) - assertEquals(PlatzTyp.VORBEREITUNG, values[1]) - assertEquals(PlatzTyp.LONGIEREN, values[2]) - assertEquals(PlatzTyp.SONSTIGES, values[3]) - - // Test serialization and deserialization - testEnumSerialization(PlatzTyp.AUSTRAGUNG) - testEnumSerialization(PlatzTyp.VORBEREITUNG) - testEnumSerialization(PlatzTyp.LONGIEREN) - testEnumSerialization(PlatzTyp.SONSTIGES) - - // Test comparison - assertEquals(PlatzTyp.AUSTRAGUNG, PlatzTyp.AUSTRAGUNG) - assertNotEquals(PlatzTyp.AUSTRAGUNG, PlatzTyp.VORBEREITUNG) - } - - @Test - fun testNennungsArtEnum() { - // Test all enum values - val values = NennungsArt.entries.toTypedArray() - assertEquals(6, values.size) - - // Test specific enum values - assertEquals(NennungsArt.OEPS_ZNS, values[0]) - assertEquals(NennungsArt.EIGENES_ONLINE, values[1]) - assertEquals(NennungsArt.DIREKT_VERANSTALTER_EMAIL, values[2]) - assertEquals(NennungsArt.DIREKT_VERANSTALTER_TELEFON, values[3]) - assertEquals(NennungsArt.DIREKT_VERANSTALTER_WHATSAPP, values[4]) - assertEquals(NennungsArt.SONSTIGE, values[5]) - - // Test serialization and deserialization - testEnumSerialization(NennungsArt.OEPS_ZNS) - testEnumSerialization(NennungsArt.EIGENES_ONLINE) - testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_EMAIL) - testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_TELEFON) - testEnumSerialization(NennungsArt.DIREKT_VERANSTALTER_WHATSAPP) - testEnumSerialization(NennungsArt.SONSTIGE) - - // Test comparison - assertEquals(NennungsArt.OEPS_ZNS, NennungsArt.OEPS_ZNS) - assertNotEquals(NennungsArt.OEPS_ZNS, NennungsArt.EIGENES_ONLINE) - } - - @Test - fun testSparteEnum() { - // Test all enum values - val values = SparteE.entries.toTypedArray() - assertEquals(12, values.size) - - // Test specific enum values - assertEquals(SparteE.DRESSUR, values[0]) - assertEquals(SparteE.SPRINGEN, values[1]) - assertEquals(SparteE.VIELSEITIGKEIT, values[2]) - assertEquals(SparteE.FAHREN, values[3]) - assertEquals(SparteE.VOLTIGIEREN, values[4]) - assertEquals(SparteE.WESTERN, values[5]) - assertEquals(SparteE.DISTANZ, values[6]) - assertEquals(SparteE.ISLAND, values[7]) - assertEquals(SparteE.PFERDESPORT_SPIEL, values[8]) - assertEquals(SparteE.BASIS, values[9]) - assertEquals(SparteE.KOMBINIERT, values[10]) - assertEquals(SparteE.SONSTIGES, values[11]) - - // Test serialization and deserialization - testEnumSerialization(SparteE.DRESSUR) - testEnumSerialization(SparteE.SPRINGEN) - testEnumSerialization(SparteE.VIELSEITIGKEIT) - testEnumSerialization(SparteE.FAHREN) - testEnumSerialization(SparteE.VOLTIGIEREN) - testEnumSerialization(SparteE.WESTERN) - testEnumSerialization(SparteE.DISTANZ) - testEnumSerialization(SparteE.ISLAND) - testEnumSerialization(SparteE.PFERDESPORT_SPIEL) - testEnumSerialization(SparteE.BASIS) - testEnumSerialization(SparteE.KOMBINIERT) - testEnumSerialization(SparteE.SONSTIGES) - - // Test comparison - assertEquals(SparteE.DRESSUR, SparteE.DRESSUR) - assertNotEquals(SparteE.DRESSUR, SparteE.SPRINGEN) - } - - @Test - fun testBewerbStatusEnum() { - // Test all enum values - val values = BewerbStatus.entries.toTypedArray() - assertEquals(6, values.size) - - // Test specific enum values - assertEquals(BewerbStatus.GEPLANT, values[0]) - assertEquals(BewerbStatus.OFFEN_FUER_NENNUNG, values[1]) - assertEquals(BewerbStatus.GESCHLOSSEN_FUER_NENNUNG, values[2]) - assertEquals(BewerbStatus.LAEUFT, values[3]) - assertEquals(BewerbStatus.ABGESCHLOSSEN, values[4]) - assertEquals(BewerbStatus.ABGESAGT, values[5]) - - // Test serialization and deserialization - testEnumSerialization(BewerbStatus.GEPLANT) - testEnumSerialization(BewerbStatus.OFFEN_FUER_NENNUNG) - testEnumSerialization(BewerbStatus.GESCHLOSSEN_FUER_NENNUNG) - testEnumSerialization(BewerbStatus.LAEUFT) - testEnumSerialization(BewerbStatus.ABGESCHLOSSEN) - testEnumSerialization(BewerbStatus.ABGESAGT) - - // Test comparison - assertEquals(BewerbStatus.GEPLANT, BewerbStatus.GEPLANT) - assertNotEquals(BewerbStatus.GEPLANT, BewerbStatus.ABGESAGT) - } - - @Test - fun testBedingungstypEnum() { - // Test all enum values - val values = Bedingungstyp.entries.toTypedArray() - assertEquals(9, values.size) - - // Test specific enum values - assertEquals(Bedingungstyp.LIZENZ_REITER, values[0]) - assertEquals(Bedingungstyp.LIZENZ_FAHRER, values[1]) - assertEquals(Bedingungstyp.ALTER_PFERD, values[2]) - assertEquals(Bedingungstyp.ALTER_REITER, values[3]) - assertEquals(Bedingungstyp.RASSE_PFERD, values[4]) - assertEquals(Bedingungstyp.GESCHLECHT_PFERD, values[5]) - assertEquals(Bedingungstyp.GESCHLECHT_REITER, values[6]) - assertEquals(Bedingungstyp.STARTKARTE, values[7]) - assertEquals(Bedingungstyp.SONSTIGES, values[8]) - - // Test serialization and deserialization - testEnumSerialization(Bedingungstyp.LIZENZ_REITER) - testEnumSerialization(Bedingungstyp.LIZENZ_FAHRER) - testEnumSerialization(Bedingungstyp.ALTER_PFERD) - testEnumSerialization(Bedingungstyp.ALTER_REITER) - testEnumSerialization(Bedingungstyp.RASSE_PFERD) - testEnumSerialization(Bedingungstyp.GESCHLECHT_PFERD) - testEnumSerialization(Bedingungstyp.GESCHLECHT_REITER) - testEnumSerialization(Bedingungstyp.STARTKARTE) - testEnumSerialization(Bedingungstyp.SONSTIGES) - - // Test comparison - assertEquals(Bedingungstyp.LIZENZ_REITER, Bedingungstyp.LIZENZ_REITER) - assertNotEquals(Bedingungstyp.LIZENZ_REITER, Bedingungstyp.LIZENZ_FAHRER) - } - - @Test - fun testOperatorEnum() { - // Test all enum values - val values = Operator.entries.toTypedArray() - assertEquals(7, values.size) - - // Test specific enum values - assertEquals(Operator.GLEICH, values[0]) - assertEquals(Operator.UNGLEICH, values[1]) - assertEquals(Operator.MINDESTENS, values[2]) - assertEquals(Operator.MAXIMAL, values[3]) - assertEquals(Operator.ZWISCHEN, values[4]) - assertEquals(Operator.IN_LISTE, values[5]) - assertEquals(Operator.NICHT_IN_LISTE, values[6]) - - // Test serialization and deserialization - testEnumSerialization(Operator.GLEICH) - testEnumSerialization(Operator.UNGLEICH) - testEnumSerialization(Operator.MINDESTENS) - testEnumSerialization(Operator.MAXIMAL) - testEnumSerialization(Operator.ZWISCHEN) - testEnumSerialization(Operator.IN_LISTE) - testEnumSerialization(Operator.NICHT_IN_LISTE) - - // Test comparison - assertEquals(Operator.GLEICH, Operator.GLEICH) - assertNotEquals(Operator.GLEICH, Operator.UNGLEICH) - } - - @Test - fun testFunktionaerRolleEnum() { - // Test all enum values - val values = FunktionaerRolle.entries.toTypedArray() - assertEquals(12, values.size) - - // Test specific enum values - assertEquals(FunktionaerRolle.RICHTER, values[0]) - assertEquals(FunktionaerRolle.PARCOURSBAUER, values[1]) - assertEquals(FunktionaerRolle.PARCOURSBAU_ASSISTENT, values[2]) - assertEquals(FunktionaerRolle.TECHN_DELEGIERTER, values[3]) - assertEquals(FunktionaerRolle.TURNIERBEAUFTRAGTER, values[4]) - assertEquals(FunktionaerRolle.STEWARD, values[5]) - assertEquals(FunktionaerRolle.ZEITNEHMER, values[6]) - assertEquals(FunktionaerRolle.SCHREIBER, values[7]) - assertEquals(FunktionaerRolle.VERANSTALTER_KONTAKT, values[8]) - assertEquals(FunktionaerRolle.TURNIERLEITER, values[9]) - assertEquals(FunktionaerRolle.HELFER, values[10]) - assertEquals(FunktionaerRolle.SONSTIGE, values[11]) - - // Test serialization and deserialization - testEnumSerialization(FunktionaerRolle.RICHTER) - testEnumSerialization(FunktionaerRolle.PARCOURSBAUER) - testEnumSerialization(FunktionaerRolle.PARCOURSBAU_ASSISTENT) - testEnumSerialization(FunktionaerRolle.TECHN_DELEGIERTER) - testEnumSerialization(FunktionaerRolle.TURNIERBEAUFTRAGTER) - testEnumSerialization(FunktionaerRolle.STEWARD) - testEnumSerialization(FunktionaerRolle.ZEITNEHMER) - testEnumSerialization(FunktionaerRolle.SCHREIBER) - testEnumSerialization(FunktionaerRolle.VERANSTALTER_KONTAKT) - testEnumSerialization(FunktionaerRolle.TURNIERLEITER) - testEnumSerialization(FunktionaerRolle.HELFER) - testEnumSerialization(FunktionaerRolle.SONSTIGE) - - // Test comparison - assertEquals(FunktionaerRolle.RICHTER, FunktionaerRolle.RICHTER) - assertNotEquals(FunktionaerRolle.RICHTER, FunktionaerRolle.PARCOURSBAUER) - } - - @Test - fun testRichterPositionEnum() { - // Test all enum values - val values = RichterPosition.entries.toTypedArray() - assertEquals(8, values.size) - - // Test specific enum values - assertEquals(RichterPosition.BEI_C, values[0]) - assertEquals(RichterPosition.BEI_E, values[1]) - assertEquals(RichterPosition.BEI_H, values[2]) - assertEquals(RichterPosition.BEI_M, values[3]) - assertEquals(RichterPosition.BEI_B, values[4]) - assertEquals(RichterPosition.VORSITZ, values[5]) - assertEquals(RichterPosition.SEITENRICHTER, values[6]) - assertEquals(RichterPosition.SONSTIGE, values[7]) - - // Test serialization and deserialization - testEnumSerialization(RichterPosition.BEI_C) - testEnumSerialization(RichterPosition.BEI_E) - testEnumSerialization(RichterPosition.BEI_H) - testEnumSerialization(RichterPosition.BEI_M) - testEnumSerialization(RichterPosition.BEI_B) - testEnumSerialization(RichterPosition.VORSITZ) - testEnumSerialization(RichterPosition.SEITENRICHTER) - testEnumSerialization(RichterPosition.SONSTIGE) - - // Test comparison - assertEquals(RichterPosition.BEI_C, RichterPosition.BEI_C) - assertNotEquals(RichterPosition.BEI_C, RichterPosition.BEI_E) - } - - @Test - fun testGeschlechtEnum() { - // Test all enum values - val values = Geschlecht.entries.toTypedArray() - assertEquals(4, values.size) - - // Test specific enum values - assertEquals(Geschlecht.M, values[0]) - assertEquals(Geschlecht.W, values[1]) - assertEquals(Geschlecht.D, values[2]) - assertEquals(Geschlecht.UNBEKANNT, values[3]) - - // Test serialization and deserialization - testEnumSerialization(Geschlecht.M) - testEnumSerialization(Geschlecht.W) - testEnumSerialization(Geschlecht.D) - testEnumSerialization(Geschlecht.UNBEKANNT) - - // Test comparison - assertEquals(Geschlecht.M, Geschlecht.M) - assertNotEquals(Geschlecht.M, Geschlecht.W) - } - - @Test - fun testLizenzTypEnum() { - // Test all enum values - val values = LizenzTyp.entries.toTypedArray() - assertEquals(15, values.size) - - // Test specific enum values - assertEquals(LizenzTyp.REITER, values[0]) - assertEquals(LizenzTyp.FAHRER, values[1]) - assertEquals(LizenzTyp.VOLTIGIERER, values[2]) - assertEquals(LizenzTyp.WESTERN, values[3]) - assertEquals(LizenzTyp.WORKING_EQUITATION, values[4]) - assertEquals(LizenzTyp.POLO, values[5]) - assertEquals(LizenzTyp.STARTKARTE_ALLG, values[6]) - assertEquals(LizenzTyp.STARTKARTE_VOLTIGIEREN, values[7]) - assertEquals(LizenzTyp.STARTKARTE_WESTERN, values[8]) - assertEquals(LizenzTyp.STARTKARTE_ISLAND, values[9]) - assertEquals(LizenzTyp.STARTKARTE_FAHREN_JUGEND, values[10]) - assertEquals(LizenzTyp.STARTKARTE_HORSEBALL, values[11]) - assertEquals(LizenzTyp.STARTKARTE_POLO, values[12]) - assertEquals(LizenzTyp.PARAEQUESTRIAN, values[13]) - assertEquals(LizenzTyp.SONSTIGE, values[14]) - - // Test serialization and deserialization - testEnumSerialization(LizenzTyp.REITER) - testEnumSerialization(LizenzTyp.FAHRER) - testEnumSerialization(LizenzTyp.VOLTIGIERER) - testEnumSerialization(LizenzTyp.WESTERN) - testEnumSerialization(LizenzTyp.WORKING_EQUITATION) - testEnumSerialization(LizenzTyp.POLO) - testEnumSerialization(LizenzTyp.STARTKARTE_ALLG) - testEnumSerialization(LizenzTyp.STARTKARTE_VOLTIGIEREN) - testEnumSerialization(LizenzTyp.STARTKARTE_WESTERN) - testEnumSerialization(LizenzTyp.STARTKARTE_ISLAND) - testEnumSerialization(LizenzTyp.STARTKARTE_FAHREN_JUGEND) - testEnumSerialization(LizenzTyp.STARTKARTE_HORSEBALL) - testEnumSerialization(LizenzTyp.STARTKARTE_POLO) - testEnumSerialization(LizenzTyp.PARAEQUESTRIAN) - testEnumSerialization(LizenzTyp.SONSTIGE) - - // Test comparison - assertEquals(LizenzTyp.REITER, LizenzTyp.REITER) - assertNotEquals(LizenzTyp.REITER, LizenzTyp.FAHRER) - } - - @Test - fun testGeschlechtPferdEnum() { - // Test all enum values - val values = GeschlechtPferd.entries.toTypedArray() - assertEquals(4, values.size) - - // Test specific enum values - assertEquals(GeschlechtPferd.HENGST, values[0]) - assertEquals(GeschlechtPferd.STUTE, values[1]) - assertEquals(GeschlechtPferd.WALLACH, values[2]) - assertEquals(GeschlechtPferd.UNBEKANNT, values[3]) - - // Test serialization and deserialization - testEnumSerialization(GeschlechtPferd.HENGST) - testEnumSerialization(GeschlechtPferd.STUTE) - testEnumSerialization(GeschlechtPferd.WALLACH) - testEnumSerialization(GeschlechtPferd.UNBEKANNT) - - // Test comparison - assertEquals(GeschlechtPferd.HENGST, GeschlechtPferd.HENGST) - assertNotEquals(GeschlechtPferd.HENGST, GeschlechtPferd.STUTE) - } - - @Test - fun testEnumCollections() { - // Test using enums in collections - val enumSet = setOf( - Geschlecht.M, - Geschlecht.W, - FunktionaerRolle.RICHTER, - FunktionaerRolle.PARCOURSBAUER - ) - - assertTrue(enumSet.contains(Geschlecht.M)) - assertTrue(enumSet.contains(FunktionaerRolle.RICHTER)) - assertEquals(4, enumSet.size) - - // Test serialization of collections with enums - @Serializable - data class TestClass( - val geschlecht: Geschlecht, - val rollen: Set - ) - - val testObject = TestClass( - geschlecht = Geschlecht.M, - rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.PARCOURSBAUER) - ) - - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"geschlecht\"")) - assertTrue(jsonString.contains("\"M\"")) - assertTrue(jsonString.contains("\"rollen\"")) - assertTrue(jsonString.contains("\"RICHTER\"")) - assertTrue(jsonString.contains("\"PARCOURSBAUER\"")) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(testObject.geschlecht, deserializedObject.geschlecht) - assertEquals(testObject.rollen, deserializedObject.rollen) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: VeranstalterTyp) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: PlatzTyp) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: NennungsArt) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: SparteE) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: BewerbStatus) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: Bedingungstyp) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: Operator) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: FunktionaerRolle) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: RichterPosition) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: Geschlecht) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: LizenzTyp) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } - - // Test serialization for a specific enum value - private fun testEnumSerialization(value: GeschlechtPferd) { - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(value) - - // Verify serialization - assertEquals("\"${value.name}\"", jsonString) - - // Verify deserialization - val deserializedValue = json.decodeFromString(jsonString) - assertEquals(value, deserializedValue) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/serializers/SerializationTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/serializers/SerializationTest.kt deleted file mode 100644 index d7bce5e5..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/serializers/SerializationTest.kt +++ /dev/null @@ -1,229 +0,0 @@ -package at.mocode.shared.serializers - -import com.benasher44.uuid.Uuid -import com.benasher44.uuid.uuid4 -import com.benasher44.uuid.uuidFrom -import com.ionspin.kotlin.bignum.decimal.BigDecimal -import kotlinx.datetime.Clock -import kotlinx.datetime.Instant -import kotlinx.datetime.LocalDate -import kotlinx.datetime.LocalDateTime -import kotlinx.serialization.Serializable -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertTrue - -class SerializationTest { - - @Test - fun testBigDecimalSerializer() { - // Test regular values - testBigDecimalSerialization(BigDecimal.fromInt(0)) - testBigDecimalSerialization(BigDecimal.fromInt(42)) - testBigDecimalSerialization(BigDecimal.fromInt(-42)) - testBigDecimalSerialization(BigDecimal.parseString("123.456")) - testBigDecimalSerialization(BigDecimal.parseString("-123.456")) - - // Test edge cases - testBigDecimalSerialization(BigDecimal.fromInt(Int.MAX_VALUE)) - testBigDecimalSerialization(BigDecimal.fromInt(Int.MIN_VALUE)) - testBigDecimalSerialization(BigDecimal.parseString("9999999999999999999.9999999999")) - testBigDecimalSerialization(BigDecimal.parseString("-9999999999999999999.9999999999")) - } - - private fun testBigDecimalSerialization(value: BigDecimal) { - @Serializable - data class TestClass( - @Serializable(with = BigDecimalSerializer::class) - val value: BigDecimal - ) - - val testObject = TestClass(value) - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"value\"")) - assertTrue(jsonString.contains(value.toStringExpanded())) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(value, deserializedObject.value) - } - - @Test - fun testUuidSerializer() { - // Test regular UUIDs - testUuidSerialization(uuid4()) - testUuidSerialization(uuidFrom("00000000-0000-0000-0000-000000000000")) - testUuidSerialization(uuidFrom("ffffffff-ffff-ffff-ffff-ffffffffffff")) - - // Test specific UUID formats - testUuidSerialization(uuidFrom("12345678-1234-5678-1234-567812345678")) - } - - private fun testUuidSerialization(value: Uuid) { - @Serializable - data class TestClass( - @Serializable(with = UuidSerializer::class) - val id: Uuid - ) - - val testObject = TestClass(value) - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"id\"")) - assertTrue(jsonString.contains(value.toString())) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(value, deserializedObject.id) - } - - @Test - fun testKotlinInstantSerializer() { - // Test current time - testInstantSerialization(Clock.System.now()) - - // Test specific instants - testInstantSerialization(Instant.parse("2023-01-01T00:00:00Z")) - testInstantSerialization(Instant.parse("1970-01-01T00:00:00Z")) - testInstantSerialization(Instant.parse("2099-12-31T23:59:59.999Z")) - - // Test with different time zones - testInstantSerialization(Instant.parse("2023-06-15T12:30:45.123+02:00")) - } - - private fun testInstantSerialization(value: Instant) { - @Serializable - data class TestClass( - @Serializable(with = KotlinInstantSerializer::class) - val timestamp: Instant - ) - - val testObject = TestClass(value) - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"timestamp\"")) - assertTrue(jsonString.contains(value.toString())) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(value, deserializedObject.timestamp) - } - - @Test - fun testKotlinLocalDateSerializer() { - // Test regular dates - testLocalDateSerialization(LocalDate(2023, 1, 1)) - testLocalDateSerialization(LocalDate(2000, 2, 29)) // Leap year - testLocalDateSerialization(LocalDate(1970, 1, 1)) - - // Test edge cases - testLocalDateSerialization(LocalDate(1, 1, 1)) - testLocalDateSerialization(LocalDate(9999, 12, 31)) - } - - private fun testLocalDateSerialization(value: LocalDate) { - @Serializable - data class TestClass( - @Serializable(with = KotlinLocalDateSerializer::class) - val date: LocalDate - ) - - val testObject = TestClass(value) - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"date\"")) - assertTrue(jsonString.contains(value.toString())) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(value, deserializedObject.date) - } - - @Test - fun testKotlinLocalDateTimeSerializer() { - // Test regular date-times - testLocalDateTimeSerialization(LocalDateTime(2023, 1, 1, 12, 0, 0)) - testLocalDateTimeSerialization(LocalDateTime(2000, 2, 29, 23, 59, 59)) // Leap year - testLocalDateTimeSerialization(LocalDateTime(1970, 1, 1, 0, 0, 0)) - - // Test with nanoseconds - testLocalDateTimeSerialization(LocalDateTime(2023, 6, 15, 12, 30, 45, 123456789)) - - // Test edge cases - testLocalDateTimeSerialization(LocalDateTime(1, 1, 1, 0, 0, 0)) - testLocalDateTimeSerialization(LocalDateTime(9999, 12, 31, 23, 59, 59, 999999999)) - } - - private fun testLocalDateTimeSerialization(value: LocalDateTime) { - @Serializable - data class TestClass( - @Serializable(with = KotlinLocalDateTimeSerializer::class) - val dateTime: LocalDateTime - ) - - val testObject = TestClass(value) - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(testObject) - - // Verify serialization - assertTrue(jsonString.contains("\"dateTime\"")) - assertTrue(jsonString.contains(value.toString())) - - // Verify deserialization - val deserializedObject = json.decodeFromString(jsonString) - assertEquals(value, deserializedObject.dateTime) - } - - @Test - fun testAllSerializersInSingleObject() { - @Serializable - data class ComplexObject( - @Serializable(with = UuidSerializer::class) - val id: Uuid, - @Serializable(with = BigDecimalSerializer::class) - val amount: BigDecimal, - @Serializable(with = KotlinInstantSerializer::class) - val createdAt: Instant, - @Serializable(with = KotlinLocalDateSerializer::class) - val date: LocalDate, - @Serializable(with = KotlinLocalDateTimeSerializer::class) - val dateTime: LocalDateTime - ) - - val obj = ComplexObject( - id = uuid4(), - amount = BigDecimal.parseString("123.456"), - createdAt = Clock.System.now(), - date = LocalDate(2023, 1, 1), - dateTime = LocalDateTime(2023, 1, 1, 12, 0, 0) - ) - - val json = Json { prettyPrint = true } - val jsonString = json.encodeToString(obj) - - // Verify serialization contains all fields - assertTrue(jsonString.contains("\"id\"")) - assertTrue(jsonString.contains("\"amount\"")) - assertTrue(jsonString.contains("\"createdAt\"")) - assertTrue(jsonString.contains("\"date\"")) - assertTrue(jsonString.contains("\"dateTime\"")) - - // Verify deserialization - val deserializedObj = json.decodeFromString(jsonString) - assertEquals(obj.id, deserializedObj.id) - assertEquals(obj.amount, deserializedObj.amount) - assertEquals(obj.createdAt, deserializedObj.createdAt) - assertEquals(obj.date, deserializedObj.date) - assertEquals(obj.dateTime, deserializedObj.dateTime) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/LizenzInfoTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/LizenzInfoTest.kt deleted file mode 100644 index febc6a1b..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/LizenzInfoTest.kt +++ /dev/null @@ -1,166 +0,0 @@ -package at.mocode.shared.stammdaten - -import at.mocode.shared.enums.LizenzTyp -import at.mocode.shared.enums.SparteE -import kotlinx.datetime.LocalDate -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertTrue - -class LizenzInfoTest { - - @Test - fun testCreateLizenzInfoWithMinimalParameters() { - // Create a LizenzInfo with minimal required parameters - val lizenzInfo = LizenzInfo( - lizenzTyp = LizenzTyp.REITER, - stufe = null, - sparteE = null, - gueltigBisJahr = null, - ausgestelltAm = null - ) - - // Verify required fields - assertEquals(LizenzTyp.REITER, lizenzInfo.lizenzTyp) - - // Verify optional fields are null - assertEquals(null, lizenzInfo.stufe) - assertEquals(null, lizenzInfo.sparteE) - assertEquals(null, lizenzInfo.gueltigBisJahr) - assertEquals(null, lizenzInfo.ausgestelltAm) - } - - @Test - fun testCreateLizenzInfoWithAllParameters() { - // Create a LizenzInfo with all parameters - val ausgestelltAm = LocalDate(2023, 1, 15) - - val lizenzInfo = LizenzInfo( - lizenzTyp = LizenzTyp.FAHRER, - stufe = "A", - sparteE = SparteE.DRESSUR, - gueltigBisJahr = 2024, - ausgestelltAm = ausgestelltAm - ) - - // Verify all fields - assertEquals(LizenzTyp.FAHRER, lizenzInfo.lizenzTyp) - assertEquals("A", lizenzInfo.stufe) - assertEquals(SparteE.DRESSUR, lizenzInfo.sparteE) - assertEquals(2024, lizenzInfo.gueltigBisJahr) - assertEquals(ausgestelltAm, lizenzInfo.ausgestelltAm) - } - - @Test - fun testSerializationDeserialization() { - // Create a LizenzInfo with all parameters - val ausgestelltAm = LocalDate(2023, 5, 20) - - val lizenzInfo = LizenzInfo( - lizenzTyp = LizenzTyp.VOLTIGIERER, - stufe = "B", - sparteE = SparteE.VOLTIGIEREN, - gueltigBisJahr = 2025, - ausgestelltAm = ausgestelltAm - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(lizenzInfo) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"lizenzTyp\""), "JSON should contain lizenzTyp field") - assertTrue(jsonString.contains("\"VOLTIGIERER\""), "JSON should contain value VOLTIGIERER") - assertTrue(jsonString.contains("\"stufe\""), "JSON should contain stufe field") - assertTrue(jsonString.contains("\"B\""), "JSON should contain value B") - assertTrue(jsonString.contains("\"sparte\""), "JSON should contain sparte field") - assertTrue(jsonString.contains("\"VOLTIGIEREN\""), "JSON should contain value VOLTIGIEREN") - assertTrue(jsonString.contains("\"gueltigBisJahr\""), "JSON should contain gueltigBisJahr field") - assertTrue(jsonString.contains("2025"), "JSON should contain value 2025") - assertTrue(jsonString.contains("\"ausgestelltAm\""), "JSON should contain ausgestelltAm field") - assertTrue(jsonString.contains("2023-05-20"), "JSON should contain value 2023-05-20") - - // Deserialize from JSON - val deserializedLizenzInfo = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(lizenzInfo.lizenzTyp, deserializedLizenzInfo.lizenzTyp) - assertEquals(lizenzInfo.stufe, deserializedLizenzInfo.stufe) - assertEquals(lizenzInfo.sparteE, deserializedLizenzInfo.sparteE) - assertEquals(lizenzInfo.gueltigBisJahr, deserializedLizenzInfo.gueltigBisJahr) - assertEquals(lizenzInfo.ausgestelltAm, deserializedLizenzInfo.ausgestelltAm) - } - - @Test - fun testCopyLizenzInfo() { - // Create a LizenzInfo - val original = LizenzInfo( - lizenzTyp = LizenzTyp.WESTERN, - stufe = "C", - sparteE = SparteE.WESTERN, - gueltigBisJahr = 2023, - ausgestelltAm = null - ) - - // Create a copy with some modified properties - val copy = original.copy( - stufe = "B", - gueltigBisJahr = 2024, - ausgestelltAm = LocalDate(2023, 12, 1) - ) - - // Verify copied properties - assertEquals(original.lizenzTyp, copy.lizenzTyp) - assertEquals(original.sparteE, copy.sparteE) - - // Verify modified properties - assertEquals("B", copy.stufe) - assertEquals(2024, copy.gueltigBisJahr) - assertEquals(LocalDate(2023, 12, 1), copy.ausgestelltAm) - } - - @Test - fun testDifferentLizenzTypes() { - // Test different LizenzTyp values - val lizenzTypes = listOf( - LizenzTyp.REITER, - LizenzTyp.FAHRER, - LizenzTyp.VOLTIGIERER, - LizenzTyp.WESTERN, - LizenzTyp.WORKING_EQUITATION, - LizenzTyp.POLO, - LizenzTyp.STARTKARTE_ALLG, - LizenzTyp.STARTKARTE_VOLTIGIEREN, - LizenzTyp.STARTKARTE_WESTERN, - LizenzTyp.STARTKARTE_ISLAND, - LizenzTyp.STARTKARTE_FAHREN_JUGEND, - LizenzTyp.STARTKARTE_HORSEBALL, - LizenzTyp.STARTKARTE_POLO, - LizenzTyp.PARAEQUESTRIAN, - LizenzTyp.SONSTIGE - ) - - for (lizenzTyp in lizenzTypes) { - val lizenzInfo = LizenzInfo( - lizenzTyp = lizenzTyp, - stufe = "Test", - sparteE = SparteE.SONSTIGES, - gueltigBisJahr = 2024, - ausgestelltAm = null - ) - - assertEquals(lizenzTyp, lizenzInfo.lizenzTyp) - - // Serialize and deserialize to verify enum handling - val json = Json { encodeDefaults = true } - val jsonString = json.encodeToString(lizenzInfo) - val deserializedLizenzInfo = json.decodeFromString(jsonString) - - assertEquals(lizenzTyp, deserializedLizenzInfo.lizenzTyp) - } - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PersonTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PersonTest.kt deleted file mode 100644 index 23598e31..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PersonTest.kt +++ /dev/null @@ -1,386 +0,0 @@ -package at.mocode.shared.stammdaten - -import at.mocode.shared.enums.FunktionaerRolle -import at.mocode.shared.enums.Geschlecht -import at.mocode.shared.enums.LizenzTyp -import at.mocode.shared.enums.SparteE -import com.benasher44.uuid.uuid4 -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 PersonTest { - - @Test - fun testCreatePerson() { - // Create a Person with minimal required parameters - val person = Person( - oepsSatzNr = null, - nachname = "Mustermann", - vorname = "Max", - titel = null, - geburtsdatum = null, - geschlecht = null, - nationalitaet = null, - email = null, - telefon = null, - adresse = null, - plz = null, - ort = null, - stammVereinId = null, - mitgliedsNummerIntern = null, - letzteZahlungJahr = null, - feiId = null, - sperrGrund = null - ) - - // Verify required fields - assertEquals("Mustermann", person.nachname) - assertEquals("Max", person.vorname) - - // Verify default values - assertNotNull(person.id) - assertEquals(null, person.geschlecht) - assertEquals(false, person.istGesperrt) - assertTrue(person.rollen.isEmpty()) - assertTrue(person.lizenzen.isEmpty()) - assertTrue(person.qualifikationenRichter.isEmpty()) - assertTrue(person.qualifikationenParcoursbauer.isEmpty()) - assertTrue(person.istAktiv) - assertNotNull(person.createdAt) - assertNotNull(person.updatedAt) - - // Verify optional fields are null - assertEquals(null, person.oepsSatzNr) - assertEquals(null, person.titel) - assertEquals(null, person.geburtsdatum) - assertEquals(null, person.nationalitaet) - assertEquals(null, person.email) - assertEquals(null, person.telefon) - assertEquals(null, person.adresse) - assertEquals(null, person.plz) - assertEquals(null, person.ort) - assertEquals(null, person.stammVereinId) - assertEquals(null, person.mitgliedsNummerIntern) - assertEquals(null, person.letzteZahlungJahr) - assertEquals(null, person.feiId) - assertEquals(null, person.sperrGrund) - } - - @Test - fun testCreatePersonWithAllParameters() { - // Create a Person with all parameters - val id = uuid4() - val stammVereinId = uuid4() - val now = Clock.System.now() - val geburtsdatum = LocalDate(1990, 1, 15) - val rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.TURNIERLEITER) - val lizenzen = listOf( - LizenzInfo( - lizenzTyp = LizenzTyp.REITER, - stufe = "A", - sparteE = SparteE.SPRINGEN, - gueltigBisJahr = 2024, - ausgestelltAm = null - ) - ) - val qualifikationenRichter = listOf("Springen A", "Dressur B") - val qualifikationenParcoursbauer = listOf("Springen A") - - val person = Person( - id = id, - oepsSatzNr = "12345", - nachname = "Vollständig", - vorname = "Victoria", - titel = "Dr.", - geburtsdatum = geburtsdatum, - geschlecht = Geschlecht.W, - nationalitaet = "AUT", - email = "victoria@example.com", - telefon = "+43 123 456789", - adresse = "Musterstraße 1", - plz = "1010", - ort = "Wien", - stammVereinId = stammVereinId, - mitgliedsNummerIntern = "M12345", - letzteZahlungJahr = 2023, - feiId = "FEI12345", - istGesperrt = false, - sperrGrund = null, - rollen = rollen, - lizenzen = lizenzen, - qualifikationenRichter = qualifikationenRichter, - qualifikationenParcoursbauer = qualifikationenParcoursbauer, - istAktiv = true, - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, person.id) - assertEquals("12345", person.oepsSatzNr) - assertEquals("Vollständig", person.nachname) - assertEquals("Victoria", person.vorname) - assertEquals("Dr.", person.titel) - assertEquals(geburtsdatum, person.geburtsdatum) - assertEquals(Geschlecht.W, person.geschlecht) - assertEquals("AUT", person.nationalitaet) - assertEquals("victoria@example.com", person.email) - assertEquals("+43 123 456789", person.telefon) - assertEquals("Musterstraße 1", person.adresse) - assertEquals("1010", person.plz) - assertEquals("Wien", person.ort) - assertEquals(stammVereinId, person.stammVereinId) - assertEquals("M12345", person.mitgliedsNummerIntern) - assertEquals(2023, person.letzteZahlungJahr) - assertEquals("FEI12345", person.feiId) - assertEquals(false, person.istGesperrt) - assertEquals(null, person.sperrGrund) - assertEquals(rollen, person.rollen) - assertEquals(lizenzen, person.lizenzen) - assertEquals(qualifikationenRichter, person.qualifikationenRichter) - assertEquals(qualifikationenParcoursbauer, person.qualifikationenParcoursbauer) - assertEquals(true, person.istAktiv) - assertEquals(now, person.createdAt) - assertEquals(now, person.updatedAt) - } - - @Test - fun testModifyPerson() { - // Create a Person - val person = Person( - oepsSatzNr = null, - nachname = "Original", - vorname = "Otto", - titel = null, - geburtsdatum = null, - geschlecht = null, - nationalitaet = null, - email = null, - telefon = null, - adresse = null, - plz = null, - ort = null, - stammVereinId = null, - mitgliedsNummerIntern = null, - letzteZahlungJahr = null, - feiId = null, - sperrGrund = null - ) - - val originalUpdatedAt = person.updatedAt - val stammVereinId = uuid4() - val geburtsdatum = LocalDate(1985, 5, 20) - val rollen = setOf(FunktionaerRolle.PARCOURSBAUER) - val lizenzen = listOf( - LizenzInfo( - lizenzTyp = LizenzTyp.FAHRER, - stufe = "B", - sparteE = SparteE.DRESSUR, - gueltigBisJahr = 2025, - ausgestelltAm = null - ) - ) - - // Modify properties - person.oepsSatzNr = "54321" - person.nachname = "Updated" - person.vorname = "Ulrike" - person.titel = "Mag." - person.geburtsdatum = geburtsdatum - person.geschlecht = Geschlecht.W - person.nationalitaet = "GER" - person.email = "ulrike@example.com" - person.telefon = "+49 987 654321" - person.adresse = "Neue Straße 2" - person.plz = "10115" - person.ort = "Berlin" - person.stammVereinId = stammVereinId - person.mitgliedsNummerIntern = "M54321" - person.letzteZahlungJahr = 2024 - person.feiId = "FEI54321" - person.istGesperrt = true - person.sperrGrund = "Administrativer Grund" - person.rollen = rollen - person.lizenzen = lizenzen - person.qualifikationenRichter = listOf("Neue Qualifikation") - person.qualifikationenParcoursbauer = listOf("Parcours A", "Parcours B") - person.istAktiv = false - person.updatedAt = Clock.System.now() - - // Verify modifications - assertEquals("54321", person.oepsSatzNr) - assertEquals("Updated", person.nachname) - assertEquals("Ulrike", person.vorname) - assertEquals("Mag.", person.titel) - assertEquals(geburtsdatum, person.geburtsdatum) - assertEquals(Geschlecht.W, person.geschlecht) - assertEquals("GER", person.nationalitaet) - assertEquals("ulrike@example.com", person.email) - assertEquals("+49 987 654321", person.telefon) - assertEquals("Neue Straße 2", person.adresse) - assertEquals("10115", person.plz) - assertEquals("Berlin", person.ort) - assertEquals(stammVereinId, person.stammVereinId) - assertEquals("M54321", person.mitgliedsNummerIntern) - assertEquals(2024, person.letzteZahlungJahr) - assertEquals("FEI54321", person.feiId) - assertEquals(true, person.istGesperrt) - assertEquals("Administrativer Grund", person.sperrGrund) - assertEquals(rollen, person.rollen) - assertEquals(lizenzen, person.lizenzen) - assertEquals(listOf("Neue Qualifikation"), person.qualifikationenRichter) - assertEquals(listOf("Parcours A", "Parcours B"), person.qualifikationenParcoursbauer) - assertEquals(false, person.istAktiv) - // Skip updatedAt verification for wasmJs compatibility - // The updatedAt field is properly set, but comparison in wasmJs environment is problematic - } - - @Test - fun testSerializationDeserialization() { - // Create a Person with all parameters - val stammVereinId = uuid4() - val geburtsdatum = LocalDate(1980, 3, 10) - val rollen = setOf(FunktionaerRolle.RICHTER, FunktionaerRolle.STEWARD) - val lizenzen = listOf( - LizenzInfo( - lizenzTyp = LizenzTyp.REITER, - stufe = "A", - sparteE = SparteE.SPRINGEN, - gueltigBisJahr = 2024, - ausgestelltAm = null - ) - ) - - val person = Person( - oepsSatzNr = "12345", - nachname = "Serialization", - vorname = "Samuel", - titel = "Prof.", - geburtsdatum = geburtsdatum, - geschlecht = Geschlecht.M, - nationalitaet = "AUT", - email = "samuel@example.com", - telefon = "+43 123 456789", - adresse = "Testgasse 3", - plz = "8010", - ort = "Graz", - stammVereinId = stammVereinId, - mitgliedsNummerIntern = "M12345", - letzteZahlungJahr = 2023, - feiId = "FEI12345", - istGesperrt = false, - sperrGrund = null, - rollen = rollen, - lizenzen = lizenzen, - qualifikationenRichter = listOf("Springen A"), - qualifikationenParcoursbauer = emptyList(), - istAktiv = true - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(person) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"nachname\""), "JSON should contain nachname field") - assertTrue(jsonString.contains("\"Serialization\""), "JSON should contain value Serialization") - assertTrue(jsonString.contains("\"vorname\""), "JSON should contain vorname field") - assertTrue(jsonString.contains("\"Samuel\""), "JSON should contain value Samuel") - assertTrue(jsonString.contains("\"geschlecht\""), "JSON should contain geschlecht field") - assertTrue(jsonString.contains("\"M\""), "JSON should contain value M") - assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field") - assertTrue(jsonString.contains("\"stammVereinId\""), "JSON should contain stammVereinId field") - assertTrue(jsonString.contains(stammVereinId.toString()), "JSON should contain stammVereinId value") - assertTrue(jsonString.contains("\"rollen\""), "JSON should contain rollen field") - assertTrue(jsonString.contains("\"RICHTER\""), "JSON should contain value RICHTER") - assertTrue(jsonString.contains("\"STEWARD\""), "JSON should contain value STEWARD") - - // Deserialize from JSON - val deserializedPerson = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(person.id, deserializedPerson.id) - assertEquals(person.oepsSatzNr, deserializedPerson.oepsSatzNr) - assertEquals(person.nachname, deserializedPerson.nachname) - assertEquals(person.vorname, deserializedPerson.vorname) - assertEquals(person.titel, deserializedPerson.titel) - assertEquals(person.geburtsdatum, deserializedPerson.geburtsdatum) - assertEquals(person.geschlecht, deserializedPerson.geschlecht) - assertEquals(person.nationalitaet, deserializedPerson.nationalitaet) - assertEquals(person.email, deserializedPerson.email) - assertEquals(person.telefon, deserializedPerson.telefon) - assertEquals(person.adresse, deserializedPerson.adresse) - assertEquals(person.plz, deserializedPerson.plz) - assertEquals(person.ort, deserializedPerson.ort) - assertEquals(person.stammVereinId, deserializedPerson.stammVereinId) - assertEquals(person.mitgliedsNummerIntern, deserializedPerson.mitgliedsNummerIntern) - assertEquals(person.letzteZahlungJahr, deserializedPerson.letzteZahlungJahr) - assertEquals(person.feiId, deserializedPerson.feiId) - assertEquals(person.istGesperrt, deserializedPerson.istGesperrt) - assertEquals(person.sperrGrund, deserializedPerson.sperrGrund) - assertEquals(person.rollen, deserializedPerson.rollen) - assertEquals(person.lizenzen, deserializedPerson.lizenzen) - assertEquals(person.qualifikationenRichter, deserializedPerson.qualifikationenRichter) - assertEquals(person.qualifikationenParcoursbauer, deserializedPerson.qualifikationenParcoursbauer) - assertEquals(person.istAktiv, deserializedPerson.istAktiv) - assertEquals(person.createdAt, deserializedPerson.createdAt) - assertEquals(person.updatedAt, deserializedPerson.updatedAt) - } - - @Test - fun testCopyPerson() { - // Create a Person - val original = Person( - oepsSatzNr = null, - nachname = "Original", - vorname = "Otto", - titel = null, - geburtsdatum = null, - geschlecht = null, - nationalitaet = null, - email = null, - telefon = null, - adresse = null, - plz = null, - ort = null, - stammVereinId = null, - mitgliedsNummerIntern = null, - letzteZahlungJahr = null, - feiId = null, - sperrGrund = null - ) - - val stammVereinId = uuid4() - val geburtsdatum = LocalDate(1975, 8, 30) - - // Create a copy with some modified properties - val copy = original.copy( - nachname = "Copy", - vorname = "Clara", - geburtsdatum = geburtsdatum, - stammVereinId = stammVereinId, - rollen = setOf(FunktionaerRolle.ZEITNEHMER) - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.oepsSatzNr, copy.oepsSatzNr) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals("Copy", copy.nachname) - assertEquals("Clara", copy.vorname) - assertEquals(geburtsdatum, copy.geburtsdatum) - assertEquals(stammVereinId, copy.stammVereinId) - assertEquals(setOf(FunktionaerRolle.ZEITNEHMER), copy.rollen) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PferdTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PferdTest.kt deleted file mode 100644 index cc8baad2..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/PferdTest.kt +++ /dev/null @@ -1,311 +0,0 @@ -package at.mocode.shared.stammdaten - -import at.mocode.shared.enums.GeschlechtPferd -import com.benasher44.uuid.uuid4 -import kotlinx.datetime.Clock -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class PferdTest { - - @Test - fun testCreatePferd() { - // Create a Pferd with minimal required parameters - val pferd = Pferd( - oepsKopfNr = null, - oepsSatzNr = null, - name = "Test Pferd", - lebensnummer = null, - feiPassNr = null, - geschlecht = null, - geburtsjahr = null, - rasse = null, - farbe = null, - vaterName = null, - mutterName = null, - mutterVaterName = null, - besitzerId = null, - verantwortlichePersonId = null, - heimatVereinId = null, - letzteZahlungJahrOeps = null, - stockmassCm = null - ) - - // Verify required fields - assertEquals("Test Pferd", pferd.name) - - // Verify default values - assertNotNull(pferd.id) - assertTrue(pferd.istAktiv) - assertNotNull(pferd.createdAt) - assertNotNull(pferd.updatedAt) - - // Verify optional fields are null - assertEquals(null, pferd.oepsKopfNr) - assertEquals(null, pferd.oepsSatzNr) - assertEquals(null, pferd.lebensnummer) - assertEquals(null, pferd.feiPassNr) - assertEquals(null, pferd.geschlecht) - assertEquals(null, pferd.geburtsjahr) - assertEquals(null, pferd.rasse) - assertEquals(null, pferd.farbe) - assertEquals(null, pferd.vaterName) - assertEquals(null, pferd.mutterName) - assertEquals(null, pferd.mutterVaterName) - assertEquals(null, pferd.besitzerId) - assertEquals(null, pferd.verantwortlichePersonId) - assertEquals(null, pferd.heimatVereinId) - assertEquals(null, pferd.letzteZahlungJahrOeps) - assertEquals(null, pferd.stockmassCm) - } - - @Test - fun testCreatePferdWithAllParameters() { - // Create a Pferd with all parameters - val id = uuid4() - val besitzerId = uuid4() - val verantwortlichePersonId = uuid4() - val heimatVereinId = uuid4() - val now = Clock.System.now() - - val pferd = Pferd( - id = id, - oepsKopfNr = "K12345", - oepsSatzNr = "S12345", - name = "Vollständiges Pferd", - lebensnummer = "AT123456789", - feiPassNr = "FEI12345", - geschlecht = GeschlechtPferd.WALLACH, - geburtsjahr = 2015, - rasse = "Hannoveraner", - farbe = "Fuchs", - vaterName = "Vater Pferd", - mutterName = "Mutter Pferd", - mutterVaterName = "Muttervater Pferd", - besitzerId = besitzerId, - verantwortlichePersonId = verantwortlichePersonId, - heimatVereinId = heimatVereinId, - letzteZahlungJahrOeps = 2023, - stockmassCm = 168, - istAktiv = true, - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, pferd.id) - assertEquals("K12345", pferd.oepsKopfNr) - assertEquals("S12345", pferd.oepsSatzNr) - assertEquals("Vollständiges Pferd", pferd.name) - assertEquals("AT123456789", pferd.lebensnummer) - assertEquals("FEI12345", pferd.feiPassNr) - assertEquals(GeschlechtPferd.WALLACH, pferd.geschlecht) - assertEquals(2015, pferd.geburtsjahr) - assertEquals("Hannoveraner", pferd.rasse) - assertEquals("Fuchs", pferd.farbe) - assertEquals("Vater Pferd", pferd.vaterName) - assertEquals("Mutter Pferd", pferd.mutterName) - assertEquals("Muttervater Pferd", pferd.mutterVaterName) - assertEquals(besitzerId, pferd.besitzerId) - assertEquals(verantwortlichePersonId, pferd.verantwortlichePersonId) - assertEquals(heimatVereinId, pferd.heimatVereinId) - assertEquals(2023, pferd.letzteZahlungJahrOeps) - assertEquals(168, pferd.stockmassCm) - assertEquals(true, pferd.istAktiv) - assertEquals(now, pferd.createdAt) - assertEquals(now, pferd.updatedAt) - } - - @Test - fun testModifyPferd() { - // Create a Pferd - val pferd = Pferd( - oepsKopfNr = null, - oepsSatzNr = null, - name = "Test Pferd", - lebensnummer = null, - feiPassNr = null, - geschlecht = null, - geburtsjahr = null, - rasse = null, - farbe = null, - vaterName = null, - mutterName = null, - mutterVaterName = null, - besitzerId = null, - verantwortlichePersonId = null, - heimatVereinId = null, - letzteZahlungJahrOeps = null, - stockmassCm = null - ) - - val originalUpdatedAt = pferd.updatedAt - val besitzerId = uuid4() - val verantwortlichePersonId = uuid4() - val heimatVereinId = uuid4() - - // Modify properties - pferd.oepsKopfNr = "K54321" - pferd.oepsSatzNr = "S54321" - pferd.name = "Updated Pferd" - pferd.lebensnummer = "AT987654321" - pferd.feiPassNr = "FEI54321" - pferd.geschlecht = GeschlechtPferd.STUTE - pferd.geburtsjahr = 2018 - pferd.rasse = "Trakehner" - pferd.farbe = "Rappe" - pferd.vaterName = "Neuer Vater" - pferd.mutterName = "Neue Mutter" - pferd.mutterVaterName = "Neuer Muttervater" - pferd.besitzerId = besitzerId - pferd.verantwortlichePersonId = verantwortlichePersonId - pferd.heimatVereinId = heimatVereinId - pferd.letzteZahlungJahrOeps = 2024 - pferd.stockmassCm = 165 - pferd.istAktiv = false - pferd.updatedAt = Clock.System.now() - - // Verify modifications - assertEquals("K54321", pferd.oepsKopfNr) - assertEquals("S54321", pferd.oepsSatzNr) - assertEquals("Updated Pferd", pferd.name) - assertEquals("AT987654321", pferd.lebensnummer) - assertEquals("FEI54321", pferd.feiPassNr) - assertEquals(GeschlechtPferd.STUTE, pferd.geschlecht) - assertEquals(2018, pferd.geburtsjahr) - assertEquals("Trakehner", pferd.rasse) - assertEquals("Rappe", pferd.farbe) - assertEquals("Neuer Vater", pferd.vaterName) - assertEquals("Neue Mutter", pferd.mutterName) - assertEquals("Neuer Muttervater", pferd.mutterVaterName) - assertEquals(besitzerId, pferd.besitzerId) - assertEquals(verantwortlichePersonId, pferd.verantwortlichePersonId) - assertEquals(heimatVereinId, pferd.heimatVereinId) - assertEquals(2024, pferd.letzteZahlungJahrOeps) - assertEquals(165, pferd.stockmassCm) - assertEquals(false, pferd.istAktiv) - // Skip updatedAt verification for wasmJs compatibility - // The updatedAt field is properly set, but comparison in wasmJs environment is problematic - } - - @Test - fun testSerializationDeserialization() { - // Create a Pferd with all parameters - val besitzerId = uuid4() - val verantwortlichePersonId = uuid4() - val heimatVereinId = uuid4() - - val pferd = Pferd( - oepsKopfNr = "K12345", - oepsSatzNr = "S12345", - name = "Serialization Pferd", - lebensnummer = "AT123456789", - feiPassNr = "FEI12345", - geschlecht = GeschlechtPferd.HENGST, - geburtsjahr = 2016, - rasse = "Holsteiner", - farbe = "Schimmel", - vaterName = "Vater Pferd", - mutterName = "Mutter Pferd", - mutterVaterName = "Muttervater Pferd", - besitzerId = besitzerId, - verantwortlichePersonId = verantwortlichePersonId, - heimatVereinId = heimatVereinId, - letzteZahlungJahrOeps = 2023, - stockmassCm = 170, - istAktiv = true - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(pferd) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"name\""), "JSON should contain name field") - assertTrue(jsonString.contains("\"Serialization Pferd\""), "JSON should contain value Serialization Pferd") - assertTrue(jsonString.contains("\"geschlecht\""), "JSON should contain geschlecht field") - assertTrue(jsonString.contains("\"HENGST\""), "JSON should contain value HENGST") - assertTrue(jsonString.contains("\"rasse\""), "JSON should contain rasse field") - assertTrue(jsonString.contains("\"Holsteiner\""), "JSON should contain value Holsteiner") - assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field") - assertTrue(jsonString.contains("\"besitzerId\""), "JSON should contain besitzerId field") - assertTrue(jsonString.contains(besitzerId.toString()), "JSON should contain besitzerId value") - - // Deserialize from JSON - val deserializedPferd = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(pferd.id, deserializedPferd.id) - assertEquals(pferd.oepsKopfNr, deserializedPferd.oepsKopfNr) - assertEquals(pferd.oepsSatzNr, deserializedPferd.oepsSatzNr) - assertEquals(pferd.name, deserializedPferd.name) - assertEquals(pferd.lebensnummer, deserializedPferd.lebensnummer) - assertEquals(pferd.feiPassNr, deserializedPferd.feiPassNr) - assertEquals(pferd.geschlecht, deserializedPferd.geschlecht) - assertEquals(pferd.geburtsjahr, deserializedPferd.geburtsjahr) - assertEquals(pferd.rasse, deserializedPferd.rasse) - assertEquals(pferd.farbe, deserializedPferd.farbe) - assertEquals(pferd.vaterName, deserializedPferd.vaterName) - assertEquals(pferd.mutterName, deserializedPferd.mutterName) - assertEquals(pferd.mutterVaterName, deserializedPferd.mutterVaterName) - assertEquals(pferd.besitzerId, deserializedPferd.besitzerId) - assertEquals(pferd.verantwortlichePersonId, deserializedPferd.verantwortlichePersonId) - assertEquals(pferd.heimatVereinId, deserializedPferd.heimatVereinId) - assertEquals(pferd.letzteZahlungJahrOeps, deserializedPferd.letzteZahlungJahrOeps) - assertEquals(pferd.stockmassCm, deserializedPferd.stockmassCm) - assertEquals(pferd.istAktiv, deserializedPferd.istAktiv) - assertEquals(pferd.createdAt, deserializedPferd.createdAt) - assertEquals(pferd.updatedAt, deserializedPferd.updatedAt) - } - - @Test - fun testCopyPferd() { - // Create a Pferd - val original = Pferd( - oepsKopfNr = null, - oepsSatzNr = null, - name = "Original Pferd", - lebensnummer = null, - feiPassNr = null, - geschlecht = null, - geburtsjahr = null, - rasse = null, - farbe = null, - vaterName = null, - mutterName = null, - mutterVaterName = null, - besitzerId = null, - verantwortlichePersonId = null, - heimatVereinId = null, - letzteZahlungJahrOeps = null, - stockmassCm = null - ) - - val besitzerId = uuid4() - - // Create a copy with some modified properties - val copy = original.copy( - name = "Copy Pferd", - rasse = "Arabisches Vollblut", - besitzerId = besitzerId - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.oepsKopfNr, copy.oepsKopfNr) - assertEquals(original.oepsSatzNr, copy.oepsSatzNr) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals("Copy Pferd", copy.name) - assertEquals("Arabisches Vollblut", copy.rasse) - assertEquals(besitzerId, copy.besitzerId) - } -} diff --git a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/VereinTest.kt b/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/VereinTest.kt deleted file mode 100644 index ffbe2a67..00000000 --- a/shared/src/commonTest/kotlin/at/mocode/shared/stammdaten/VereinTest.kt +++ /dev/null @@ -1,225 +0,0 @@ -package at.mocode.shared.stammdaten - -import com.benasher44.uuid.uuid4 -import kotlinx.datetime.Clock -import kotlinx.serialization.json.Json -import kotlin.test.Test -import kotlin.test.assertEquals -import kotlin.test.assertNotNull -import kotlin.test.assertTrue - -class VereinTest { - - @Test - fun testCreateVerein() { - // Create a Verein with minimal required parameters - val verein = Verein( - oepsVereinsNr = "12345", - name = "Test Verein", - kuerzel = null, - bundesland = null, - adresse = null, - plz = null, - ort = null, - email = null, - telefon = null, - webseite = null - ) - - // Verify required fields - assertEquals("12345", verein.oepsVereinsNr) - assertEquals("Test Verein", verein.name) - - // Verify default values - assertNotNull(verein.id) - assertTrue(verein.istAktiv) - assertNotNull(verein.createdAt) - assertNotNull(verein.updatedAt) - - // Verify optional fields are null - assertEquals(null, verein.kuerzel) - assertEquals(null, verein.bundesland) - assertEquals(null, verein.adresse) - assertEquals(null, verein.plz) - assertEquals(null, verein.ort) - assertEquals(null, verein.email) - assertEquals(null, verein.telefon) - assertEquals(null, verein.webseite) - } - - @Test - fun testCreateVereinWithAllParameters() { - // Create a Verein with all parameters - val id = uuid4() - val now = Clock.System.now() - - val verein = Verein( - id = id, - oepsVereinsNr = "12345", - name = "Test Verein", - kuerzel = "TV", - bundesland = "Wien", - adresse = "Teststraße 1", - plz = "1010", - ort = "Wien", - email = "test@verein.at", - telefon = "+43 1 234567", - webseite = "https://testverein.at", - istAktiv = true, - createdAt = now, - updatedAt = now - ) - - // Verify all fields - assertEquals(id, verein.id) - assertEquals("12345", verein.oepsVereinsNr) - assertEquals("Test Verein", verein.name) - assertEquals("TV", verein.kuerzel) - assertEquals("Wien", verein.bundesland) - assertEquals("Teststraße 1", verein.adresse) - assertEquals("1010", verein.plz) - assertEquals("Wien", verein.ort) - assertEquals("test@verein.at", verein.email) - assertEquals("+43 1 234567", verein.telefon) - assertEquals("https://testverein.at", verein.webseite) - assertEquals(true, verein.istAktiv) - assertEquals(now, verein.createdAt) - assertEquals(now, verein.updatedAt) - } - - @Test - fun testModifyVerein() { - // Create a Verein - val verein = Verein( - oepsVereinsNr = "12345", - name = "Test Verein", - kuerzel = null, - bundesland = null, - adresse = null, - plz = null, - ort = null, - email = null, - telefon = null, - webseite = null - ) - - val originalUpdatedAt = verein.updatedAt - - // Modify properties - verein.oepsVereinsNr = "54321" - verein.name = "Updated Verein" - verein.kuerzel = "UV" - verein.bundesland = "Salzburg" - verein.adresse = "Neue Straße 2" - verein.plz = "5020" - verein.ort = "Salzburg" - verein.email = "updated@verein.at" - verein.telefon = "+43 662 123456" - verein.webseite = "https://updatedverein.at" - verein.istAktiv = false - verein.updatedAt = Clock.System.now() - - // Verify modifications - assertEquals("54321", verein.oepsVereinsNr) - assertEquals("Updated Verein", verein.name) - assertEquals("UV", verein.kuerzel) - assertEquals("Salzburg", verein.bundesland) - assertEquals("Neue Straße 2", verein.adresse) - assertEquals("5020", verein.plz) - assertEquals("Salzburg", verein.ort) - assertEquals("updated@verein.at", verein.email) - assertEquals("+43 662 123456", verein.telefon) - assertEquals("https://updatedverein.at", verein.webseite) - assertEquals(false, verein.istAktiv) - // Skip updatedAt verification for wasmJs compatibility - // The updatedAt field is properly set, but comparison in wasmJs environment is problematic - } - - @Test - fun testSerializationDeserialization() { - // Create a Verein with all parameters - val verein = Verein( - oepsVereinsNr = "12345", - name = "Test Verein", - kuerzel = "TV", - bundesland = "Wien", - adresse = "Teststraße 1", - plz = "1010", - ort = "Wien", - email = "test@verein.at", - telefon = "+43 1 234567", - webseite = "https://testverein.at", - istAktiv = true - ) - - // Serialize to JSON - val json = Json { - prettyPrint = true - encodeDefaults = true - } - val jsonString = json.encodeToString(verein) - - // Verify JSON contains expected fields - assertTrue(jsonString.contains("\"oepsVereinsNr\""), "JSON should contain oepsVereinsNr field") - assertTrue(jsonString.contains("\"12345\""), "JSON should contain value 12345") - assertTrue(jsonString.contains("\"name\""), "JSON should contain name field") - assertTrue(jsonString.contains("\"Test Verein\""), "JSON should contain value Test Verein") - assertTrue(jsonString.contains("\"kuerzel\""), "JSON should contain kuerzel field") - assertTrue(jsonString.contains("\"TV\""), "JSON should contain value TV") - assertTrue(jsonString.contains("\"bundesland\""), "JSON should contain bundesland field") - assertTrue(jsonString.contains("\"Wien\""), "JSON should contain value Wien") - assertTrue(jsonString.contains("\"istAktiv\""), "JSON should contain istAktiv field") - - // Deserialize from JSON - val deserializedVerein = json.decodeFromString(jsonString) - - // Verify deserialized object matches original - assertEquals(verein.id, deserializedVerein.id) - assertEquals(verein.oepsVereinsNr, deserializedVerein.oepsVereinsNr) - assertEquals(verein.name, deserializedVerein.name) - assertEquals(verein.kuerzel, deserializedVerein.kuerzel) - assertEquals(verein.bundesland, deserializedVerein.bundesland) - assertEquals(verein.adresse, deserializedVerein.adresse) - assertEquals(verein.plz, deserializedVerein.plz) - assertEquals(verein.ort, deserializedVerein.ort) - assertEquals(verein.email, deserializedVerein.email) - assertEquals(verein.telefon, deserializedVerein.telefon) - assertEquals(verein.webseite, deserializedVerein.webseite) - assertEquals(verein.istAktiv, deserializedVerein.istAktiv) - assertEquals(verein.createdAt, deserializedVerein.createdAt) - assertEquals(verein.updatedAt, deserializedVerein.updatedAt) - } - - @Test - fun testCopyVerein() { - // Create a Verein - val original = Verein( - oepsVereinsNr = "12345", - name = "Test Verein", - kuerzel = null, - bundesland = null, - adresse = null, - plz = null, - ort = null, - email = null, - telefon = null, - webseite = null - ) - - // Create a copy with some modified properties - val copy = original.copy( - name = "Copy Verein", - bundesland = "Tirol" - ) - - // Verify copied properties - assertEquals(original.id, copy.id) - assertEquals(original.oepsVereinsNr, copy.oepsVereinsNr) - assertEquals(original.createdAt, copy.createdAt) - assertEquals(original.updatedAt, copy.updatedAt) - - // Verify modified properties - assertEquals("Copy Verein", copy.name) - assertEquals("Tirol", copy.bundesland) - } -}