Standardize and refactor master data infrastructure: rename tables for plural consistency, remove unused entity tables, improve ZNS import mappings with enriched license properties, introduce Altersklasse domain model, activate Consul service discovery, and update application configuration accordingly.

2026-04-06 19:48:15 +02:00
parent bc13a58a14
commit abaaeddaaf
53 changed files with 1575 additions and 333 deletions
@@ -7,10 +7,10 @@ import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
 import org.jetbrains.exposed.v1.datetime.timestamp

 /**
- * Exposed-Tabellendefinition für die Altersklasse-Entität (Altersklassendefinition).
+ * Exposed-Tabellendefinition für die Altersklassen-Entität (Altersklassendefinition).
 *
 * Diese Tabelle speichert alle Informationen zu Altersklassen für Teilnehmer
- * entsprechend der AltersklasseDefinition Domain-Entität.
+ * entsprechend der AltersklassenDefinition Domain-Entität.
 */
 object AltersklasseTable : Table("altersklasse") {
  val id = uuid("id")
@@ -29,7 +29,7 @@ object AltersklasseTable : Table("altersklasse") {
  override val primaryKey = PrimaryKey(id)

  init {
-    // Index for performance on common queries
+    // Index für Performance (an Migration angepasst)
    index(customIndexName = "idx_altersklasse_aktiv", columns = arrayOf(istAktiv))
    index(customIndexName = "idx_altersklasse_sparte", columns = arrayOf(sparteFilter))
    index(customIndexName = "idx_altersklasse_geschlecht", columns = arrayOf(geschlechtFilter))
@@ -7,12 +7,12 @@ import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
 import org.jetbrains.exposed.v1.datetime.timestamp

 /**
- * Exposed-Tabellendefinition für die Bundesland-Entität.
+ * Exposed-Tabellendefinition für die Bundesländer-Entität.
 */
-object BundeslandTable : Table("bundesland") {
-  val id = uuid("id")
+object BundeslaenderTable : Table("bundeslaender") {
+  val id = uuid("bundesland_id")
  val landId = uuid("land_id")
-  val bundeslandNr = integer("bundesland_nr").nullable()
+  val bundeslandNr = integer("bundesland_nr").uniqueIndex().nullable()
  val oepsCode = varchar("oeps_code", 10).nullable()
  val iso3166_2_Code = varchar("iso_3166_2_code", 10).nullable()
  val name = varchar("name", 100)
@@ -26,10 +26,10 @@ object BundeslandTable : Table("bundesland") {
  override val primaryKey = PrimaryKey(id)

  init {
-    uniqueIndex("idx_bundesland_oeps", oepsCode, landId)
-    uniqueIndex("idx_bundesland_iso", iso3166_2_Code)
+    uniqueIndex("idx_bundeslaender_oeps", oepsCode, landId)
+    uniqueIndex("idx_bundeslaender_iso", iso3166_2_Code)
    // Natürlicher Schlüssel gem. Architektur: (land_id + kuerzel) eindeutig
    // Hinweis: kuerzel kann NULL sein – der Unique-Index greift dann nur für nicht-null Werte pro Land.
-    uniqueIndex("ux_bundesland_land_kuerzel", landId, kuerzel)
+    uniqueIndex("ux_bundeslaender_land_kuerzel", landId, kuerzel)
  }
 }
@@ -11,46 +11,47 @@ import kotlin.uuid.Uuid

 /**
 * Implementierung des BundeslandRepository für die Datenbankzugriffe.
+ * Verwendet die Tabelle 'bundeslaender'.
 */
 class BundeslandRepositoryImpl : BundeslandRepository {

  private fun rowToBundeslandDefinition(row: ResultRow): BundeslandDefinition {
    return BundeslandDefinition(
-      bundeslandId = row[BundeslandTable.id],
-      landId = row[BundeslandTable.landId],
-      bundeslandNr = row[BundeslandTable.bundeslandNr],
-      oepsCode = row[BundeslandTable.oepsCode],
-      iso3166_2_Code = row[BundeslandTable.iso3166_2_Code],
-      name = row[BundeslandTable.name],
-      kuerzel = row[BundeslandTable.kuerzel],
-      wappenUrl = row[BundeslandTable.wappenUrl],
-      istAktiv = row[BundeslandTable.istAktiv],
-      sortierReihenfolge = row[BundeslandTable.sortierReihenfolge],
-      createdAt = row[BundeslandTable.createdAt],
-      updatedAt = row[BundeslandTable.updatedAt]
+      bundeslandId = row[BundeslaenderTable.id],
+      landId = row[BundeslaenderTable.landId],
+      bundeslandNr = row[BundeslaenderTable.bundeslandNr],
+      oepsCode = row[BundeslaenderTable.oepsCode],
+      iso3166_2_Code = row[BundeslaenderTable.iso3166_2_Code],
+      name = row[BundeslaenderTable.name],
+      kuerzel = row[BundeslaenderTable.kuerzel],
+      wappenUrl = row[BundeslaenderTable.wappenUrl],
+      istAktiv = row[BundeslaenderTable.istAktiv],
+      sortierReihenfolge = row[BundeslaenderTable.sortierReihenfolge],
+      createdAt = row[BundeslaenderTable.createdAt],
+      updatedAt = row[BundeslaenderTable.updatedAt]
    )
  }

  override suspend fun findByNr(nr: Int): BundeslandDefinition? = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { BundeslandTable.bundeslandNr eq nr }
+    BundeslaenderTable.selectAll().where { BundeslaenderTable.bundeslandNr eq nr }
      .map(::rowToBundeslandDefinition)
      .singleOrNull()
  }

  override suspend fun findById(id: Uuid): BundeslandDefinition? = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { BundeslandTable.id eq id }
+    BundeslaenderTable.selectAll().where { BundeslaenderTable.id eq id }
      .map(::rowToBundeslandDefinition)
      .singleOrNull()
  }

  override suspend fun findByOepsCode(oepsCode: String, landId: Uuid): BundeslandDefinition? = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { (BundeslandTable.oepsCode eq oepsCode) and (BundeslandTable.landId eq landId) }
+    BundeslaenderTable.selectAll().where { (BundeslaenderTable.oepsCode eq oepsCode) and (BundeslaenderTable.landId eq landId) }
      .map(::rowToBundeslandDefinition)
      .singleOrNull()
  }

  override suspend fun findByIso3166_2_Code(iso3166_2_Code: String): BundeslandDefinition? = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { BundeslandTable.iso3166_2_Code eq iso3166_2_Code }
+    BundeslaenderTable.selectAll().where { BundeslaenderTable.iso3166_2_Code eq iso3166_2_Code }
      .map(::rowToBundeslandDefinition)
      .singleOrNull()
  }
@@ -60,14 +61,14 @@ class BundeslandRepositoryImpl : BundeslandRepository {
    activeOnly: Boolean,
    orderBySortierung: Boolean
  ): List<BundeslandDefinition> = DatabaseFactory.dbQuery {
-    val query = BundeslandTable.selectAll().where { BundeslandTable.landId eq landId }
+    val query = BundeslaenderTable.selectAll().where { BundeslaenderTable.landId eq landId }
    if (activeOnly) {
-      query.andWhere { BundeslandTable.istAktiv eq true }
+      query.andWhere { BundeslaenderTable.istAktiv eq true }
    }
    if (orderBySortierung) {
-      query.orderBy(BundeslandTable.sortierReihenfolge to SortOrder.ASC, BundeslandTable.name to SortOrder.ASC)
+      query.orderBy(BundeslaenderTable.sortierReihenfolge to SortOrder.ASC, BundeslaenderTable.name to SortOrder.ASC)
    } else {
-      query.orderBy(BundeslandTable.name to SortOrder.ASC)
+      query.orderBy(BundeslaenderTable.name to SortOrder.ASC)
    }
    query.map(::rowToBundeslandDefinition)
  }
@@ -75,26 +76,27 @@ class BundeslandRepositoryImpl : BundeslandRepository {
  override suspend fun findByName(searchTerm: String, landId: Uuid?, limit: Int): List<BundeslandDefinition> =
    DatabaseFactory.dbQuery {
      val pattern = "%$searchTerm%"
-      val query = BundeslandTable.selectAll().where { BundeslandTable.name like pattern }
-      landId?.let { query.andWhere { BundeslandTable.landId eq it } }
+      val query = BundeslaenderTable.selectAll().where { BundeslaenderTable.name like pattern }
+      landId?.let { query.andWhere { BundeslaenderTable.landId eq it } }
      query.limit(limit).map(::rowToBundeslandDefinition)
    }

  override suspend fun findAllActive(orderBySortierung: Boolean): List<BundeslandDefinition> = DatabaseFactory.dbQuery {
-    val query = BundeslandTable.selectAll().where { BundeslandTable.istAktiv eq true }
+    val query = BundeslaenderTable.selectAll().where { BundeslaenderTable.istAktiv eq true }
    if (orderBySortierung) {
-      query.orderBy(BundeslandTable.sortierReihenfolge to SortOrder.ASC, BundeslandTable.name to SortOrder.ASC)
+      query.orderBy(BundeslaenderTable.sortierReihenfolge to SortOrder.ASC, BundeslaenderTable.name to SortOrder.ASC)
    } else {
-      query.orderBy(BundeslandTable.name to SortOrder.ASC)
+      query.orderBy(BundeslaenderTable.name to SortOrder.ASC)
    }
    query.map(::rowToBundeslandDefinition)
  }

  override suspend fun save(bundesland: BundeslandDefinition): BundeslandDefinition = DatabaseFactory.dbQuery {
-    val exists = BundeslandTable.selectAll().where { BundeslandTable.id eq bundesland.bundeslandId }.any()
+    val exists = BundeslaenderTable.selectAll().where { BundeslaenderTable.id eq bundesland.bundeslandId }.any()
    if (exists) {
-      BundeslandTable.update({ BundeslandTable.id eq bundesland.bundeslandId }) {
+      BundeslaenderTable.update({ BundeslaenderTable.id eq bundesland.bundeslandId }) {
        it[landId] = bundesland.landId
+        it[bundeslandNr] = bundesland.bundeslandNr
        it[oepsCode] = bundesland.oepsCode
        it[iso3166_2_Code] = bundesland.iso3166_2_Code
        it[name] = bundesland.name
@@ -106,9 +108,10 @@ class BundeslandRepositoryImpl : BundeslandRepository {
      }
      bundesland
    } else {
-      BundeslandTable.insert {
+      BundeslaenderTable.insert {
        it[id] = bundesland.bundeslandId
        it[landId] = bundesland.landId
+        it[bundeslandNr] = bundesland.bundeslandNr
        it[oepsCode] = bundesland.oepsCode
        it[iso3166_2_Code] = bundesland.iso3166_2_Code
        it[name] = bundesland.name
@@ -124,31 +127,31 @@ class BundeslandRepositoryImpl : BundeslandRepository {
  }

  override suspend fun delete(id: Uuid): Boolean = DatabaseFactory.dbQuery {
-    BundeslandTable.deleteWhere { BundeslandTable.id eq id } > 0
+    BundeslaenderTable.deleteWhere { BundeslaenderTable.id eq id } > 0
  }

  override suspend fun existsByOepsCode(oepsCode: String, landId: Uuid): Boolean = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { (BundeslandTable.oepsCode eq oepsCode) and (BundeslandTable.landId eq landId) }
+    BundeslaenderTable.selectAll().where { (BundeslaenderTable.oepsCode eq oepsCode) and (BundeslaenderTable.landId eq landId) }
      .any()
  }

  override suspend fun existsByIso3166_2_Code(iso3166_2_Code: String): Boolean = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { BundeslandTable.iso3166_2_Code eq iso3166_2_Code }.any()
+    BundeslaenderTable.selectAll().where { BundeslaenderTable.iso3166_2_Code eq iso3166_2_Code }.any()
  }

  override suspend fun countActiveByCountry(landId: Uuid): Long = DatabaseFactory.dbQuery {
-    BundeslandTable.selectAll().where { (BundeslandTable.landId eq landId) and (BundeslandTable.istAktiv eq true) }
+    BundeslaenderTable.selectAll().where { (BundeslaenderTable.landId eq landId) and (BundeslaenderTable.istAktiv eq true) }
      .count()
  }

  override suspend fun upsertByLandIdAndKuerzel(bundesland: BundeslandDefinition): BundeslandDefinition = DatabaseFactory.dbQuery {
    // 1) Update anhand des natürlichen Schlüssels (landId + kuerzel)
    val updated = if (bundesland.kuerzel == null) {
-      // Ohne Kuerzel ist der natürliche Schlüssel nicht definiert → versuche Update via (landId + name) als Fallback nicht, bleib bei None
      0
    } else {
-      BundeslandTable.update({ (BundeslandTable.landId eq bundesland.landId) and (BundeslandTable.kuerzel eq bundesland.kuerzel) }) {
+      BundeslaenderTable.update({ (BundeslaenderTable.landId eq bundesland.landId) and (BundeslaenderTable.kuerzel eq bundesland.kuerzel) }) {
        it[landId] = bundesland.landId
+        it[bundeslandNr] = bundesland.bundeslandNr
        it[oepsCode] = bundesland.oepsCode
        it[iso3166_2_Code] = bundesland.iso3166_2_Code
        it[name] = bundesland.name
@@ -161,16 +164,17 @@ class BundeslandRepositoryImpl : BundeslandRepository {
    }

    if (updated > 0) {
-      BundeslandTable.selectAll()
-        .where { (BundeslandTable.landId eq bundesland.landId) and (BundeslandTable.kuerzel eq bundesland.kuerzel) }
+      BundeslaenderTable.selectAll()
+        .where { (BundeslaenderTable.landId eq bundesland.landId) and (BundeslaenderTable.kuerzel eq bundesland.kuerzel) }
        .map(::rowToBundeslandDefinition)
        .single()
    } else {
      // 2) Insert versuchen
      try {
-        BundeslandTable.insert {
+        BundeslaenderTable.insert {
          it[id] = bundesland.bundeslandId
          it[landId] = bundesland.landId
+          it[bundeslandNr] = bundesland.bundeslandNr
          it[oepsCode] = bundesland.oepsCode
          it[iso3166_2_Code] = bundesland.iso3166_2_Code
          it[name] = bundesland.name
@@ -184,8 +188,9 @@ class BundeslandRepositoryImpl : BundeslandRepository {
      } catch (_: Exception) {
        // Race-Condition → erneut Update
        if (bundesland.kuerzel != null) {
-          BundeslandTable.update({ (BundeslandTable.landId eq bundesland.landId) and (BundeslandTable.kuerzel eq bundesland.kuerzel) }) {
+          BundeslaenderTable.update({ (BundeslaenderTable.landId eq bundesland.landId) and (BundeslaenderTable.kuerzel eq bundesland.kuerzel) }) {
            it[landId] = bundesland.landId
+            it[bundeslandNr] = bundesland.bundeslandNr
            it[oepsCode] = bundesland.oepsCode
            it[iso3166_2_Code] = bundesland.iso3166_2_Code
            it[name] = bundesland.name
@@ -197,14 +202,14 @@ class BundeslandRepositoryImpl : BundeslandRepository {
          }
        }
      }
-      // Rückgabe des aktuellen Datensatzes: Falls Kuerzel null greift auf ID zurück
+
      if (bundesland.kuerzel != null) {
-        BundeslandTable.selectAll()
-          .where { (BundeslandTable.landId eq bundesland.landId) and (BundeslandTable.kuerzel eq bundesland.kuerzel) }
+        BundeslaenderTable.selectAll()
+          .where { (BundeslaenderTable.landId eq bundesland.landId) and (BundeslaenderTable.kuerzel eq bundesland.kuerzel) }
          .map(::rowToBundeslandDefinition)
          .single()
      } else {
-        BundeslandTable.selectAll().where { BundeslandTable.id eq bundesland.bundeslandId }
+        BundeslaenderTable.selectAll().where { BundeslaenderTable.id eq bundesland.bundeslandId }
          .map(::rowToBundeslandDefinition)
          .single()
      }
@@ -19,10 +19,15 @@ import kotlin.time.Instant as KxInstant
 class ExposedRegulationRepository : RegulationRepository {

  override suspend fun findAllTurnierklassen(): List<TurnierklasseDefinition> = DatabaseFactory.dbQuery {
-    TurnierklasseTable.selectAll()
+    TurnierKlassenTable.selectAll()
      .map { it.toTurnierklasseDefinition() }
  }

+  override suspend fun findAllBewerbsklassen(): List<BewerbsklasseDefinition> = DatabaseFactory.dbQuery {
+    TurnierKlassenTable.selectAll()
+      .map { it.toBewerbsklasseDefinition() }
+  }
+
  override suspend fun findAllLicenseMatrixEntries(): List<LicenseMatrixEntry> = DatabaseFactory.dbQuery {
    LicenseTable.selectAll()
      .map { it.toLicenseMatrixEntry() }
@@ -55,18 +60,32 @@ class ExposedRegulationRepository : RegulationRepository {
      }
  }

+  private fun ResultRow.toBewerbsklasseDefinition() = BewerbsklasseDefinition(
+    bewerbsklasseId = this[TurnierKlassenTable.id],
+    sparte = SparteE.valueOf(this[TurnierKlassenTable.sparte]),
+    code = this[TurnierKlassenTable.code],
+    bezeichnung = this[TurnierKlassenTable.bezeichnung],
+    maxHoehe = this[TurnierKlassenTable.maxHoehe],
+    aufgabenNiveau = this[TurnierKlassenTable.aufgabenNiveau],
+    validFrom = this[TurnierKlassenTable.validFrom].toKtInstant(),
+    validTo = this[TurnierKlassenTable.validTo]?.toOptionalKtInstant(),
+    istAktiv = this[TurnierKlassenTable.istAktiv],
+    createdAt = this[TurnierKlassenTable.createdAt].toKtInstant(),
+    updatedAt = this[TurnierKlassenTable.updatedAt].toKtInstant()
+  )
+
  private fun ResultRow.toTurnierklasseDefinition() = TurnierklasseDefinition(
-    turnierklasseId = this[TurnierklasseTable.id],
-    sparte = SparteE.valueOf(this[TurnierklasseTable.sparte]),
-    code = this[TurnierklasseTable.code],
-    bezeichnung = this[TurnierklasseTable.bezeichnung],
-    maxHoehe = this[TurnierklasseTable.maxHoehe],
-    aufgabenNiveau = this[TurnierklasseTable.aufgabenNiveau],
-    validFrom = this[TurnierklasseTable.validFrom].toKtInstant(),
-    validTo = this[TurnierklasseTable.validTo]?.toOptionalKtInstant(),
-    istAktiv = this[TurnierklasseTable.istAktiv],
-    createdAt = this[TurnierklasseTable.createdAt].toKtInstant(),
-    updatedAt = this[TurnierklasseTable.updatedAt].toKtInstant()
+    turnierklasseId = this[TurnierKlassenTable.id],
+    sparte = SparteE.valueOf(this[TurnierKlassenTable.sparte]),
+    code = this[TurnierKlassenTable.code],
+    bezeichnung = this[TurnierKlassenTable.bezeichnung],
+    maxHoehe = this[TurnierKlassenTable.maxHoehe],
+    aufgabenNiveau = this[TurnierKlassenTable.aufgabenNiveau],
+    validFrom = this[TurnierKlassenTable.validFrom].toKtInstant(),
+    validTo = this[TurnierKlassenTable.validTo]?.toOptionalKtInstant(),
+    istAktiv = this[TurnierKlassenTable.istAktiv],
+    createdAt = this[TurnierKlassenTable.createdAt].toKtInstant(),
+    updatedAt = this[TurnierKlassenTable.updatedAt].toKtInstant()
  )

  private fun ResultRow.toLicenseMatrixEntry() = LicenseMatrixEntry(
@@ -1,27 +0,0 @@
-@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
-
-package at.mocode.masterdata.infrastructure.persistence
-
-import at.mocode.masterdata.infrastructure.persistence.reiter.ReiterTable
-import org.jetbrains.exposed.v1.core.Table
-import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
-import org.jetbrains.exposed.v1.datetime.timestamp
-
-/**
- * Exposed-Tabellendefinition für die Spartenberechtigung eines Reiters.
- * Verknüpft einen Reiter mit den Sparten (DRESSUR, SPRINGEN), für die er lizenziert ist.
- */
-object ReiterSparteTable : Table("reiter_sparte") {
-  val id = uuid("id")
-  val reiterId = uuid("reiter_id").references(ReiterTable.id)
-  val sparte = varchar("sparte", 20) // DRESSUR, SPRINGEN
-
-  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
-  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
-
-  override val primaryKey = PrimaryKey(id)
-
-  init {
-    uniqueIndex("ux_reiter_sparte", reiterId, sparte)
-  }
-}
@@ -0,0 +1,22 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.masterdata.infrastructure.persistence
+
+import org.jetbrains.exposed.v1.core.Table
+import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
+import org.jetbrains.exposed.v1.datetime.timestamp
+
+/**
+ * Exposed-Tabellendefinition für Turnier-Kategorien (z.B. CSN-B, CDN-A).
+ */
+object TurnierKategorienTable : Table("turnier_kategorien") {
+  val id = uuid("kategorie_id")
+  val code = varchar("code", 20).uniqueIndex()
+  val bezeichnung = varchar("bezeichnung", 100)
+  val sparte = varchar("sparte", 20).nullable()
+  val istAktiv = bool("ist_aktiv").default(true)
+  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
+  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
+
+  override val primaryKey = PrimaryKey(id)
+}
@@ -7,11 +7,11 @@ import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
 import org.jetbrains.exposed.v1.datetime.timestamp

 /**
- * Exposed-Tabellendefinition für Turnierklassen (Springen/Dressur).
+ * Exposed-Tabellendefinition für Bewerbsklassen (Springen/Dressur).
 * Basierend auf ÖTO 2026.
 */
-object TurnierklasseTable : Table("turnierklasse") {
-  val id = uuid("turnierklasse_id")
+object TurnierKlassenTable : Table("bewerbs_klassen") {
+  val id = uuid("bewerbsklasse_id")
  val sparte = varchar("sparte", 20) // DRESSUR, SPRINGEN
  val code = varchar("code", 10) // E, A, L, LM, M, S
  val bezeichnung = varchar("bezeichnung", 100)
@@ -29,6 +29,6 @@ object TurnierklasseTable : Table("turnierklasse") {
  override val primaryKey = PrimaryKey(id)

  init {
-    index("idx_turnierklasse_sparte_code", false, sparte, code)
+    index("idx_bewerbs_klassen_sparte_code", false, sparte, code)
  }
 }
@@ -0,0 +1,21 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.masterdata.infrastructure.persistence
+
+import org.jetbrains.exposed.v1.core.Table
+import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
+import org.jetbrains.exposed.v1.datetime.timestamp
+
+/**
+ * Exposed-Tabellendefinition für Turnier-Sparten (z.B. Dressur, Springen, Fahren).
+ */
+object TurnierSpartenTable : Table("turnier_sparten") {
+  val id = uuid("sparte_id")
+  val code = varchar("code", 10).uniqueIndex() // z.B. D, S, V, F, R, C
+  val bezeichnung = varchar("bezeichnung", 100)
+  val istAktiv = bool("ist_aktiv").default(true)
+  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
+  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
+
+  override val primaryKey = PrimaryKey(id)
+}
@@ -5,10 +5,7 @@ import at.mocode.core.domain.model.DatenQuelleE
 import at.mocode.core.utils.database.DatabaseFactory
 import at.mocode.masterdata.domain.model.Funktionaer
 import at.mocode.masterdata.domain.repository.FunktionaerRepository
-import org.jetbrains.exposed.v1.core.ResultRow
-import org.jetbrains.exposed.v1.core.and
-import org.jetbrains.exposed.v1.core.eq
-import org.jetbrains.exposed.v1.core.inList
+import org.jetbrains.exposed.v1.core.*
 import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.selectAll
@@ -20,7 +17,7 @@ import kotlin.uuid.Uuid
 * Exposed-basierte Implementierung des Funktionaer-Repositorys.
 *
 * Verwaltet die Persistenz von Funktionären und deren Qualifikationen.
- * Die Qualifikationen werden beim Speichern gegen die [QualifikationMasterTable]
+ * Die Qualifikationen werden beim Speichern gegen die [FunktionaersQualifikationenTable]
 * aufgelöst, um Datenintegrität bezüglich offizieller ÖTO-Kürzel sicherzustellen.
 */
 class FunktionaerExposedRepository : FunktionaerRepository {
@@ -44,9 +41,9 @@ class FunktionaerExposedRepository : FunktionaerRepository {
  }

  override suspend fun findById(id: Uuid): Funktionaer? = DatabaseFactory.dbQuery {
-    val qualifikationen = (FunktionaerQualifikationTable innerJoin QualifikationMasterTable)
+    val qualifikationen = (FunktionaerQualifikationTable innerJoin FunktionaersQualifikationenTable)
      .selectAll().where { FunktionaerQualifikationTable.funktionaerId eq id }
-      .map { it[QualifikationMasterTable.code] }
+      .map { it[FunktionaersQualifikationenTable.code] }

    FunktionaerTable.selectAll().where { FunktionaerTable.id eq id }
      .map { rowToDomFunktionaer(it, qualifikationen) }
@@ -58,9 +55,9 @@ class FunktionaerExposedRepository : FunktionaerRepository {
      .where { (FunktionaerTable.satzId eq satzID) and (FunktionaerTable.satzNummer eq satzNummer) }
      .singleOrNull() ?: return@dbQuery null

-    val qualifikationen = (FunktionaerQualifikationTable innerJoin QualifikationMasterTable)
+    val qualifikationen = (FunktionaerQualifikationTable innerJoin FunktionaersQualifikationenTable)
      .selectAll().where { FunktionaerQualifikationTable.funktionaerId eq row[FunktionaerTable.id] }
-      .map { it[QualifikationMasterTable.code] }
+      .map { it[FunktionaersQualifikationenTable.code] }

    rowToDomFunktionaer(row, qualifikationen)
  }
@@ -71,9 +68,9 @@ class FunktionaerExposedRepository : FunktionaerRepository {
      .toList()

    val ids = funktionaere.map { it[FunktionaerTable.id] }
-    val qualisMap = (FunktionaerQualifikationTable innerJoin QualifikationMasterTable)
+    val qualisMap = (FunktionaerQualifikationTable innerJoin FunktionaersQualifikationenTable)
      .selectAll().where { FunktionaerQualifikationTable.funktionaerId inList ids }
-      .groupBy({ it[FunktionaerQualifikationTable.funktionaerId] }) { it[QualifikationMasterTable.code] }
+      .groupBy({ it[FunktionaerQualifikationTable.funktionaerId] }) { it[FunktionaersQualifikationenTable.code] }

    funktionaere.map { row ->
      rowToDomFunktionaer(row, qualisMap[row[FunktionaerTable.id]] ?: emptyList())
@@ -118,9 +115,9 @@ class FunktionaerExposedRepository : FunktionaerRepository {
    val typ = if (funktionaer.istRichter()) "RICHTER" else "PARCOURSBAUER"

    funktionaer.qualifikationen.forEach { code ->
-      val masterId = QualifikationMasterTable
-        .selectAll().where { (QualifikationMasterTable.code eq code) and (QualifikationMasterTable.typ eq typ) }
-        .map { it[QualifikationMasterTable.id] }
+      val masterId = FunktionaersQualifikationenTable
+        .selectAll().where { (FunktionaersQualifikationenTable.code eq code) and (FunktionaersQualifikationenTable.typ eq typ) }
+        .map { it[FunktionaersQualifikationenTable.id] }
        .singleOrNull()

      if (masterId != null) {
@@ -48,10 +48,10 @@ object FunktionaerTable : Table("funktionaer") {
 }

 /**
- * Exposed-Tabellendefinition für die Qualifikation-Master-Daten.
+ * Exposed-Tabellendefinition für die Qualifikation-Master-Daten (Funktionäre).
 * Enthält offizielle ÖTO/FEI Kürzel (z.B. "D", "S", "P1").
 */
-object QualifikationMasterTable : Table("qualifikation_master") {
+object FunktionaersQualifikationenTable : Table("funktionaers_qualifikationen") {
  val id = uuid("qualifikation_id")

  /** Offizielles Kürzel (z.B. "SPF" für Springpferde) */
@@ -66,7 +66,7 @@ object QualifikationMasterTable : Table("qualifikation_master") {
  override val primaryKey = PrimaryKey(id)

  init {
-    index("idx_qualifikation_code_typ", isUnique = true, code, typ)
+    index("idx_funktionaers_qualifikationen_code_typ", isUnique = true, code, typ)
  }
 }

@@ -75,7 +75,7 @@ object QualifikationMasterTable : Table("qualifikation_master") {
 */
 object FunktionaerQualifikationTable : Table("funktionaer_qualifikation") {
  val funktionaerId = uuid("funktionaer_id").references(FunktionaerTable.id)
-  val qualifikationId = uuid("qualifikation_id").references(QualifikationMasterTable.id)
+  val qualifikationId = uuid("qualifikation_id").references(FunktionaersQualifikationenTable.id)

  override val primaryKey = PrimaryKey(funktionaerId, qualifikationId)
 }
@@ -0,0 +1,37 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.masterdata.infrastructure.persistence.reiter
+
+import at.mocode.core.domain.model.SparteE
+import at.mocode.core.utils.database.DatabaseFactory
+import at.mocode.masterdata.domain.model.AltersklasseDefinition
+import at.mocode.masterdata.domain.repository.AltersklassenRepository
+import at.mocode.masterdata.infrastructure.persistence.AltersklasseTable
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.selectAll
+
+/**
+ * Exposed-basierte Implementierung des AltersklassenRepository.
+ */
+class AltersklassenExposedRepository : AltersklassenRepository {
+
+    override suspend fun findByCode(code: String): AltersklasseDefinition? = DatabaseFactory.dbQuery {
+        AltersklasseTable.selectAll().where { AltersklasseTable.altersklasseCode eq code }
+            .map {
+                AltersklasseDefinition(
+                    altersklasseId = it[AltersklasseTable.id],
+                    altersklasseCode = it[AltersklasseTable.altersklasseCode],
+                    bezeichnung = it[AltersklasseTable.bezeichnung],
+                    minAlter = it[AltersklasseTable.minAlter],
+                    maxAlter = it[AltersklasseTable.maxAlter],
+                    stichtagRegelText = it[AltersklasseTable.stichtagRegelText],
+                    sparteFilter = it[AltersklasseTable.sparteFilter]?.let { s -> SparteE.valueOf(s) },
+                    geschlechtFilter = it[AltersklasseTable.geschlechtFilter],
+                    oetoRegelReferenzId = it[AltersklasseTable.oetoRegelReferenzId],
+                    istAktiv = it[AltersklasseTable.istAktiv],
+                    createdAt = it[AltersklasseTable.createdAt],
+                    updatedAt = it[AltersklasseTable.updatedAt]
+                )
+            }.singleOrNull()
+    }
+}
@@ -5,7 +5,7 @@ package at.mocode.masterdata.infrastructure.persistence.reiter
 import at.mocode.core.utils.database.DatabaseFactory
 import at.mocode.masterdata.domain.model.BundeslandDefinition
 import at.mocode.masterdata.domain.repository.BundeslandRepository
-import at.mocode.masterdata.infrastructure.persistence.BundeslandTable
+import at.mocode.masterdata.infrastructure.persistence.BundeslaenderTable
 import org.jetbrains.exposed.v1.core.ResultRow
 import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.jdbc.selectAll
@@ -17,22 +17,22 @@ import kotlin.uuid.Uuid
 */
 class BundeslandExposedRepository : BundeslandRepository {
    private fun rowToDom(row: ResultRow) = BundeslandDefinition(
-        bundeslandId = row[BundeslandTable.id],
-        landId = row[BundeslandTable.landId],
-        bundeslandNr = row[BundeslandTable.bundeslandNr],
-        oepsCode = row[BundeslandTable.oepsCode],
-        iso3166_2_Code = row[BundeslandTable.iso3166_2_Code],
-        name = row[BundeslandTable.name],
-        kuerzel = row[BundeslandTable.kuerzel],
-        wappenUrl = row[BundeslandTable.wappenUrl],
-        istAktiv = row[BundeslandTable.istAktiv],
-        sortierReihenfolge = row[BundeslandTable.sortierReihenfolge],
-        createdAt = row[BundeslandTable.createdAt],
-        updatedAt = row[BundeslandTable.updatedAt]
+        bundeslandId = row[BundeslaenderTable.id],
+        landId = row[BundeslaenderTable.landId],
+        bundeslandNr = row[BundeslaenderTable.bundeslandNr],
+        oepsCode = row[BundeslaenderTable.oepsCode],
+        iso3166_2_Code = row[BundeslaenderTable.iso3166_2_Code],
+        name = row[BundeslaenderTable.name],
+        kuerzel = row[BundeslaenderTable.kuerzel],
+        wappenUrl = row[BundeslaenderTable.wappenUrl],
+        istAktiv = row[BundeslaenderTable.istAktiv],
+        sortierReihenfolge = row[BundeslaenderTable.sortierReihenfolge],
+        createdAt = row[BundeslaenderTable.createdAt],
+        updatedAt = row[BundeslaenderTable.updatedAt]
    )

    override suspend fun findByNr(nr: Int): BundeslandDefinition? = DatabaseFactory.dbQuery {
-        BundeslandTable.selectAll().where { BundeslandTable.bundeslandNr eq nr }
+        BundeslaenderTable.selectAll().where { BundeslaenderTable.bundeslandNr eq nr }
            .map(::rowToDom)
            .singleOrNull()
    }
@@ -0,0 +1,54 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.masterdata.infrastructure.persistence.reiter
+
+import at.mocode.core.utils.database.DatabaseFactory
+import at.mocode.masterdata.domain.model.FahrLizenz
+import at.mocode.masterdata.domain.model.ReitLizenz
+import at.mocode.masterdata.domain.model.Startkarte
+import at.mocode.masterdata.domain.repository.MasterdataLicenseRepository
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.selectAll
+
+/**
+ * Exposed-basierte Implementierung des MasterdataLicenseRepository.
+ */
+class MasterdataLicenseExposedRepository : MasterdataLicenseRepository {
+
+    override suspend fun findReitLizenzByCode(code: String): ReitLizenz? = DatabaseFactory.dbQuery {
+        ReitLizenzenTable.selectAll().where { ReitLizenzenTable.code eq code }
+            .map {
+                ReitLizenz(
+                    lizenzId = it[ReitLizenzenTable.id],
+                    code = it[ReitLizenzenTable.code],
+                    bezeichnung = it[ReitLizenzenTable.bezeichnung],
+                    sparte = it[ReitLizenzenTable.sparte],
+                    istAktiv = it[ReitLizenzenTable.istAktiv]
+                )
+            }.singleOrNull()
+    }
+
+    override suspend fun findFahrLizenzByCode(code: String): FahrLizenz? = DatabaseFactory.dbQuery {
+        FahrLizenzenTable.selectAll().where { FahrLizenzenTable.code eq code }
+            .map {
+                FahrLizenz(
+                    lizenzId = it[FahrLizenzenTable.id],
+                    code = it[FahrLizenzenTable.code],
+                    bezeichnung = it[FahrLizenzenTable.bezeichnung],
+                    istAktiv = it[FahrLizenzenTable.istAktiv]
+                )
+            }.singleOrNull()
+    }
+
+    override suspend fun findStartkarteByCode(code: String): Startkarte? = DatabaseFactory.dbQuery {
+        StartkartenTable.selectAll().where { StartkartenTable.code eq code }
+            .map {
+                Startkarte(
+                    startkarteId = it[StartkartenTable.id],
+                    code = it[StartkartenTable.code],
+                    bezeichnung = it[StartkartenTable.bezeichnung],
+                    istAktiv = it[StartkartenTable.istAktiv]
+                )
+            }.singleOrNull()
+    }
+}
@@ -3,15 +3,20 @@
 package at.mocode.masterdata.infrastructure.persistence.reiter

 import at.mocode.core.domain.model.DatenQuelleE
+import at.mocode.core.domain.model.ReiterAltersKlasseE
 import at.mocode.core.domain.model.ReiterLizenzKlasseE
 import at.mocode.core.utils.database.DatabaseFactory
 import at.mocode.masterdata.domain.model.Reiter
+import at.mocode.masterdata.domain.model.ReiterLizenz
 import at.mocode.masterdata.domain.repository.ReiterRepository
 import org.jetbrains.exposed.v1.core.ResultRow
 import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.core.lowerCase
-import org.jetbrains.exposed.v1.jdbc.*
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
+import org.jetbrains.exposed.v1.jdbc.insert
+import org.jetbrains.exposed.v1.jdbc.selectAll
+import org.jetbrains.exposed.v1.jdbc.update
 import kotlin.uuid.ExperimentalUuidApi
 import kotlin.uuid.Uuid

@@ -33,11 +38,14 @@ class ReiterExposedRepository : ReiterRepository {
      vereinId = row[ReiterTable.vereinId],
      bundeslandId = row[ReiterTable.bundeslandId],
      nationId = row[ReiterTable.nationId],
+      reitLizenzId = row[ReiterTable.reitLizenzId],
+      fahrLizenzId = row[ReiterTable.fahrLizenzId],
+      startkarteId = row[ReiterTable.startkarteId],
      reiterLizenz = row[ReiterTable.reiterLizenz],
      startkarte = row[ReiterTable.startkarte],
      fahrLizenz = row[ReiterTable.fahrLizenz],
-      altersklasseJgJrU25 = row[ReiterTable.altersklasseJgJrU25],
-      altersklasseY = row[ReiterTable.altersklasseY],
+      altersklasseJgJrU25 = row[ReiterTable.altersklasseJgJrU25]?.let { ReiterAltersKlasseE.valueOf(it) },
+      altersklasseY = row[ReiterTable.altersklasseY]?.let { ReiterAltersKlasseE.valueOf(it) },
      mitgliedsNummer = row[ReiterTable.mitgliedsNummer],
      telefonNummer = row[ReiterTable.telefonNummer],
      kader = row[ReiterTable.kader],
@@ -52,10 +60,23 @@ class ReiterExposedRepository : ReiterRepository {
      bemerkungen = row[ReiterTable.bemerkungen],
      datenQuelle = DatenQuelleE.valueOf(row[ReiterTable.datenQuelle]),
      createdAt = row[ReiterTable.createdAt],
-      updatedAt = row[ReiterTable.updatedAt]
+      updatedAt = row[ReiterTable.updatedAt],
+      lizenzen = loadLizenzen(row[ReiterTable.id])
    )
  }

+  private fun loadLizenzen(reiterId: Uuid): List<ReiterLizenz> {
+    return ReiterLizenzenZuordnungTable.selectAll().where { ReiterLizenzenZuordnungTable.reiterId eq reiterId }
+      .map {
+        at.mocode.masterdata.domain.model.ReiterLizenz(
+          lizenzId = it[ReiterLizenzenZuordnungTable.id],
+          lizenzTyp = it[ReiterLizenzenZuordnungTable.lizenzTyp],
+          kuerzel = it[ReiterLizenzenZuordnungTable.kuerzel],
+          gueltigBis = it[ReiterLizenzenZuordnungTable.gueltigBis]
+        )
+      }
+  }
+
  override suspend fun findById(id: Uuid): Reiter? = DatabaseFactory.dbQuery {
    ReiterTable.selectAll().where { ReiterTable.id eq id }
      .map { rowToDomReiter(it) }
@@ -72,7 +93,7 @@ class ReiterExposedRepository : ReiterRepository {
    ReiterTable.selectAll()
      .where {
        (ReiterTable.vorname.lowerCase() eq vorname.lowercase()) and
-        (ReiterTable.nachname.lowerCase() eq nachname.lowercase())
+          (ReiterTable.nachname.lowerCase() eq nachname.lowercase())
      }
      .map { row -> rowToDomReiter(row) }
  }
@@ -97,11 +118,14 @@ class ReiterExposedRepository : ReiterRepository {
        it[vereinId] = reiter.vereinId
        it[bundeslandId] = reiter.bundeslandId
        it[nationId] = reiter.nationId
+        it[reitLizenzId] = reiter.reitLizenzId
+        it[fahrLizenzId] = reiter.fahrLizenzId
+        it[startkarteId] = reiter.startkarteId
        it[reiterLizenz] = reiter.reiterLizenz
        it[startkarte] = reiter.startkarte
        it[fahrLizenz] = reiter.fahrLizenz
-        it[altersklasseJgJrU25] = reiter.altersklasseJgJrU25
-        it[altersklasseY] = reiter.altersklasseY
+        it[altersklasseJgJrU25] = reiter.altersklasseJgJrU25?.name
+        it[altersklasseY] = reiter.altersklasseY?.name
        it[mitgliedsNummer] = reiter.mitgliedsNummer
        it[telefonNummer] = reiter.telefonNummer
        it[kader] = reiter.kader
@@ -117,6 +141,7 @@ class ReiterExposedRepository : ReiterRepository {
        it[datenQuelle] = reiter.datenQuelle.name
        it[updatedAt] = reiter.updatedAt
      }
+      saveLizenzen(reiter)
    } else {
      ReiterTable.insert {
        it[id] = reiter.reiterId
@@ -130,11 +155,14 @@ class ReiterExposedRepository : ReiterRepository {
        it[vereinId] = reiter.vereinId
        it[bundeslandId] = reiter.bundeslandId
        it[nationId] = reiter.nationId
+        it[reitLizenzId] = reiter.reitLizenzId
+        it[fahrLizenzId] = reiter.fahrLizenzId
+        it[startkarteId] = reiter.startkarteId
        it[reiterLizenz] = reiter.reiterLizenz
        it[startkarte] = reiter.startkarte
        it[fahrLizenz] = reiter.fahrLizenz
-        it[altersklasseJgJrU25] = reiter.altersklasseJgJrU25
-        it[altersklasseY] = reiter.altersklasseY
+        it[altersklasseJgJrU25] = reiter.altersklasseJgJrU25?.name
+        it[altersklasseY] = reiter.altersklasseY?.name
        it[mitgliedsNummer] = reiter.mitgliedsNummer
        it[telefonNummer] = reiter.telefonNummer
        it[kader] = reiter.kader
@@ -151,11 +179,25 @@ class ReiterExposedRepository : ReiterRepository {
        it[createdAt] = reiter.createdAt
        it[updatedAt] = reiter.updatedAt
      }
+      saveLizenzen(reiter)
    }

    reiter
  }

+  private fun saveLizenzen(reiter: Reiter) {
+    ReiterLizenzenZuordnungTable.deleteWhere { reiterId eq reiter.reiterId }
+    reiter.lizenzen.forEach { lizenz ->
+      ReiterLizenzenZuordnungTable.insert {
+        it[id] = lizenz.lizenzId
+        it[reiterId] = reiter.reiterId
+        it[lizenzTyp] = lizenz.lizenzTyp
+        it[kuerzel] = lizenz.kuerzel
+        it[gueltigBis] = lizenz.gueltigBis
+      }
+    }
+  }
+
  override suspend fun delete(id: Uuid): Boolean = DatabaseFactory.dbQuery {
    ReiterTable.deleteWhere { ReiterTable.id eq id } > 0
  }
@@ -2,6 +2,7 @@

 package at.mocode.masterdata.infrastructure.persistence.reiter

+import at.mocode.masterdata.infrastructure.persistence.BundeslaenderTable
 import org.jetbrains.exposed.v1.core.Table
 import org.jetbrains.exposed.v1.datetime.CurrentTimestamp
 import org.jetbrains.exposed.v1.datetime.date
@@ -27,6 +28,9 @@ object ReiterTable : Table("reiter") {
  val vereinId = uuid("verein_id").nullable()
  val bundeslandId = uuid("bundesland_id").nullable()
  val nationId = uuid("nation_id").nullable()
+  val reitLizenzId = uuid("reit_lizenz_id").nullable()
+  val fahrLizenzId = uuid("fahr_lizenz_id").nullable()
+  val startkarteId = uuid("startkarte_id").nullable()

  val reiterLizenz = varchar("reiter_lizenz", 20).nullable()
  val startkarte = varchar("startkarte", 20).nullable()
@@ -65,24 +69,10 @@ object ReiterTable : Table("reiter") {
 }

 /**
- * Exposed-Tabellendefinition für die Bundesland-Mastertabelle.
+ * Exposed-Tabellendefinition für die Reiter-Lizenzen-Zuordnung (historisch/mehrfach).
 */
-object BundeslandTable : Table("bundesland") {
-  val id = uuid("bundesland_id")
-  val bundeslandNr = integer("bundesland_nr").uniqueIndex()
-  val bezeichnung = varchar("bezeichnung", 100)
-  val wappenUrl = varchar("wappen_url", 255).nullable()
-  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
-  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
-
-  override val primaryKey = PrimaryKey(id)
-}
-
-/**
- * Exposed-Tabellendefinition für die Reiter-Lizenzen.
- */
-object ReiterLizenzTable : Table("reiter_lizenz") {
-  val id = uuid("lizenz_id")
+object ReiterLizenzenZuordnungTable : Table("reiter_lizenzen_zuordnung") {
+  val id = uuid("lizenz_zuordnung_id")
  val reiterId = uuid("reiter_id")
  val lizenzTyp = varchar("lizenz_typ", 50) // STARTKARTE, REITERLIZENZ, FAHRLIZENZ
  val kuerzel = varchar("kuerzel", 20)
@@ -92,3 +82,46 @@ object ReiterLizenzTable : Table("reiter_lizenz") {

  override val primaryKey = PrimaryKey(id)
 }
+
+/**
+ * Exposed-Tabellendefinition für Reit-Lizenzen (Stammdaten).
+ */
+object ReitLizenzenTable : Table("reit_lizenzen") {
+  val id = uuid("lizenz_id")
+  val code = varchar("code", 20).uniqueIndex()
+  val bezeichnung = varchar("bezeichnung", 100)
+  val sparte = varchar("sparte", 20).nullable()
+  val istAktiv = bool("ist_aktiv").default(true)
+  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
+  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
+
+  override val primaryKey = PrimaryKey(id)
+}
+
+/**
+ * Exposed-Tabellendefinition für Fahr-Lizenzen (Stammdaten).
+ */
+object FahrLizenzenTable : Table("fahr_lizenzen") {
+  val id = uuid("lizenz_id")
+  val code = varchar("code", 20).uniqueIndex()
+  val bezeichnung = varchar("bezeichnung", 100)
+  val istAktiv = bool("ist_aktiv").default(true)
+  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
+  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
+
+  override val primaryKey = PrimaryKey(id)
+}
+
+/**
+ * Exposed-Tabellendefinition für Startkarten (Stammdaten).
+ */
+object StartkartenTable : Table("startkarten") {
+  val id = uuid("startkarte_id")
+  val code = varchar("code", 20).uniqueIndex()
+  val bezeichnung = varchar("bezeichnung", 100)
+  val istAktiv = bool("ist_aktiv").default(true)
+  val createdAt = timestamp("created_at").defaultExpression(CurrentTimestamp)
+  val updatedAt = timestamp("updated_at").defaultExpression(CurrentTimestamp)
+
+  override val primaryKey = PrimaryKey(id)
+}
@@ -28,7 +28,7 @@ class RegulationSeedVerificationTest {
    Database.connect("jdbc:h2:mem:regulationseed;DB_CLOSE_DELAY=-1", driver = "org.h2.Driver")
    transaction {
      SchemaUtils.create(
-        TurnierklasseTable,
+        TurnierKlassenTable,
        LicenseTable,
        RichtverfahrenTable,
        GebuehrTable,