impl div Klassen
This commit is contained in:
@@ -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 }
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
)
|
||||
|
||||
@@ -31,7 +31,7 @@ data class Turnier(
|
||||
var datumBis: LocalDate,
|
||||
@Serializable(with = KotlinLocalDateTimeSerializer::class) // Beispiel
|
||||
var nennungsschluss: LocalDateTime?,
|
||||
var nennungsArt: List<NennungsArt> = emptyList(),
|
||||
var nennungsArt: List<NennungsArtE> = emptyList(),
|
||||
var nennungsHinweis: String?,
|
||||
var eigenesNennsystemUrl: String?,
|
||||
@Serializable(with = BigDecimalSerializer::class)
|
||||
|
||||
@@ -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?,
|
||||
|
||||
@@ -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()
|
||||
)
|
||||
+2
-2
@@ -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
|
||||
@@ -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()
|
||||
)
|
||||
+1
-1
@@ -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
|
||||
@@ -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()
|
||||
)
|
||||
+130
@@ -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<DotierungsAbstufung> = 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()
|
||||
)
|
||||
@@ -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()
|
||||
)
|
||||
@@ -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<Uuid>. 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()
|
||||
)
|
||||
+26
@@ -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
|
||||
)
|
||||
+82
@@ -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()
|
||||
)
|
||||
+41
@@ -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
|
||||
)
|
||||
+73
@@ -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()
|
||||
)
|
||||
+69
@@ -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<RichterPositionE> = 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()
|
||||
)
|
||||
+83
@@ -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<BewerbFunktionaerZuordnung> = emptyList(), // Kommt noch
|
||||
|
||||
@Serializable(with = KotlinInstantSerializer::class)
|
||||
val createdAt: Instant = Clock.System.now(),
|
||||
@Serializable(with = KotlinInstantSerializer::class)
|
||||
var updatedAt: Instant = Clock.System.now()
|
||||
)
|
||||
@@ -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?,
|
||||
|
||||
@@ -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<Artikel>(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)
|
||||
}
|
||||
}
|
||||
-165
@@ -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<MeisterschaftReferenz>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<Platz>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<Turnier>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<Veranstaltung>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<FunktionaerRolle>
|
||||
)
|
||||
|
||||
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<TestClass>(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<VeranstalterTyp>(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<PlatzTyp>(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<NennungsArt>(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<SparteE>(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<BewerbStatus>(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<Bedingungstyp>(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<Operator>(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<FunktionaerRolle>(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<RichterPosition>(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<Geschlecht>(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<LizenzTyp>(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<GeschlechtPferd>(jsonString)
|
||||
assertEquals(value, deserializedValue)
|
||||
}
|
||||
}
|
||||
@@ -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<TestClass>(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<TestClass>(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<TestClass>(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<TestClass>(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<TestClass>(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<ComplexObject>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<LizenzInfo>(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<LizenzInfo>(jsonString)
|
||||
|
||||
assertEquals(lizenzTyp, deserializedLizenzInfo.lizenzTyp)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Person>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<Pferd>(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)
|
||||
}
|
||||
}
|
||||
@@ -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<Verein>(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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user