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.
This commit is contained in:
+57
@@ -0,0 +1,57 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.AltersklasseTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Altersklassen gemäß LIZENZ01.DAT (JG, JR, 25, Y).
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class AltersklassenSeeder {
|
||||
private val log = LoggerFactory.getLogger(AltersklassenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Altersklassen...")
|
||||
transaction {
|
||||
val klassen = listOf(
|
||||
Triple("JG", "JUGENDLICHER", "Altersklasse Jugend"),
|
||||
Triple("JR", "JUNIOR", "Altersklasse Junior"),
|
||||
Triple("25", "U25", "Altersklasse U25"),
|
||||
Triple("Y", "JUNGER-REITER", "Altersklasse Junger Reiter")
|
||||
)
|
||||
|
||||
klassen.forEach { (code, bez, desc) ->
|
||||
upsertAltersklasse(code, bez)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun upsertAltersklasse(code: String, bezeichnung: String) {
|
||||
val exists = AltersklasseTable.selectAll()
|
||||
.where { AltersklasseTable.altersklasseCode eq code }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
AltersklasseTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[altersklasseCode] = code
|
||||
it[AltersklasseTable.bezeichnung] = bezeichnung
|
||||
it[istAktiv] = true
|
||||
}
|
||||
log.debug("Altersklasse '{}' angelegt.", code)
|
||||
}
|
||||
}
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.TurnierKlassenTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Bewerbsklassen (ehemals Turnierklassen) gemäß ÖTO.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class BewerbsKlassenSeeder {
|
||||
private val log = LoggerFactory.getLogger(BewerbsKlassenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Bewerbsklassen...")
|
||||
transaction {
|
||||
seedSpringenKlassen()
|
||||
seedDressurKlassen()
|
||||
}
|
||||
log.info("Seeding der Bewerbsklassen abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun seedSpringenKlassen() {
|
||||
val klassen = listOf(
|
||||
Triple("E", "Einsteiger", 80),
|
||||
Triple("A", "Anfänger", 105),
|
||||
Triple("L", "Leicht", 115),
|
||||
Triple("LM", "Leicht-Mittel", 125),
|
||||
Triple("M", "Mittelschwer", 135),
|
||||
Triple("S", "Schwer", 150)
|
||||
)
|
||||
klassen.forEach { (code, bez, hoehe) ->
|
||||
upsertKlasse("SPRINGEN", code, bez, hoehe, null)
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedDressurKlassen() {
|
||||
val klassen = listOf(
|
||||
Triple("E", "Einsteiger", "Aufgaben E"),
|
||||
Triple("A", "Anfänger", "Aufgaben A"),
|
||||
Triple("L", "Leicht", "Aufgaben L"),
|
||||
Triple("LM", "Leicht-Mittel", "Aufgaben LM"),
|
||||
Triple("M", "Mittelschwer", "Aufgaben M"),
|
||||
Triple("S", "Schwer", "Aufgaben S")
|
||||
)
|
||||
klassen.forEach { (code, bez, niveau) ->
|
||||
upsertKlasse("DRESSUR", code, bez, null, niveau)
|
||||
}
|
||||
}
|
||||
|
||||
private fun upsertKlasse(sparte: String, code: String, bezeichnung: String, hoehe: Int?, niveau: String?) {
|
||||
val exists = TurnierKlassenTable.selectAll()
|
||||
.where { (TurnierKlassenTable.sparte eq sparte) and (TurnierKlassenTable.code eq code) }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
TurnierKlassenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[TurnierKlassenTable.sparte] = sparte
|
||||
it[TurnierKlassenTable.code] = code
|
||||
it[TurnierKlassenTable.bezeichnung] = bezeichnung
|
||||
it[TurnierKlassenTable.maxHoehe] = hoehe
|
||||
it[TurnierKlassenTable.aufgabenNiveau] = niveau
|
||||
}
|
||||
log.debug("Bewerbsklasse '{}' ({}) angelegt.", code, sparte)
|
||||
}
|
||||
}
|
||||
}
|
||||
+79
@@ -0,0 +1,79 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.FunktionaersQualifikationenTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Funktionärs-Qualifikationen.
|
||||
* Befüllt die FunktionaersQualifikationenTable mit Standard-Werten.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class FunktionaersQualifikationenSeeder {
|
||||
private val log = LoggerFactory.getLogger(FunktionaersQualifikationenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Funktionärs-Qualifikationen...")
|
||||
transaction {
|
||||
seedRichterQualifikationen()
|
||||
seedParcoursbauerQualifikationen()
|
||||
}
|
||||
log.info("Seeding der Funktionärs-Qualifikationen abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun seedRichterQualifikationen() {
|
||||
val qualis = listOf(
|
||||
"D" to "Dressur",
|
||||
"S" to "Springen",
|
||||
"DPF" to "Dressurpferde",
|
||||
"SPF" to "Springpferde",
|
||||
"G" to "Gelände",
|
||||
"STW" to "Steward",
|
||||
"DM" to "Dressur Master",
|
||||
"SM" to "Springen Master"
|
||||
)
|
||||
qualis.forEach { (code, bezeichnung) ->
|
||||
upsertQualifikation(code, bezeichnung, "RICHTER")
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedParcoursbauerQualifikationen() {
|
||||
val qualis = listOf(
|
||||
"P1" to "Einsteiger",
|
||||
"P2" to "Fortgeschritten",
|
||||
"P3" to "National",
|
||||
"P4" to "Grand Prix"
|
||||
)
|
||||
qualis.forEach { (code, bezeichnung) ->
|
||||
upsertQualifikation(code, bezeichnung, "PARCOURSBAUER")
|
||||
}
|
||||
}
|
||||
|
||||
private fun upsertQualifikation(code: String, bezeichnung: String, typ: String) {
|
||||
val exists = FunktionaersQualifikationenTable.selectAll()
|
||||
.where { (FunktionaersQualifikationenTable.code eq code) and (FunktionaersQualifikationenTable.typ eq typ) }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
FunktionaersQualifikationenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[FunktionaersQualifikationenTable.code] = code
|
||||
it[FunktionaersQualifikationenTable.bezeichnung] = bezeichnung
|
||||
it[FunktionaersQualifikationenTable.typ] = typ
|
||||
}
|
||||
log.debug("Qualifikation '{}' ({}) angelegt.", code, typ)
|
||||
}
|
||||
}
|
||||
}
|
||||
+22
-17
@@ -1,14 +1,11 @@
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.*
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.FunktionaerQualifikationTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.FunktionaerTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.QualifikationMasterTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.FunktionaersQualifikationenTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.pferd.HorseTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.ReiterTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.ReiterLizenzTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.BundeslandTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.*
|
||||
import at.mocode.masterdata.infrastructure.persistence.verein.VereinTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import jakarta.annotation.PreDestroy
|
||||
@@ -46,22 +43,26 @@ class MasterdataDatabaseConfiguration(
|
||||
transaction {
|
||||
SchemaUtils.create(
|
||||
LandTable,
|
||||
BundeslandTable,
|
||||
BundeslaenderTable,
|
||||
AltersklasseTable,
|
||||
PlatzTable,
|
||||
ReiterTable,
|
||||
HorseTable,
|
||||
VereinTable,
|
||||
FunktionaerTable,
|
||||
QualifikationMasterTable,
|
||||
FunktionaersQualifikationenTable,
|
||||
FunktionaerQualifikationTable,
|
||||
ReiterLizenzTable,
|
||||
TurnierklasseTable,
|
||||
ReitLizenzenTable,
|
||||
FahrLizenzenTable,
|
||||
StartkartenTable,
|
||||
ReiterLizenzenZuordnungTable,
|
||||
TurnierKlassenTable,
|
||||
TurnierSpartenTable,
|
||||
TurnierKategorienTable,
|
||||
LicenseTable,
|
||||
RichtverfahrenTable,
|
||||
GebuehrTable,
|
||||
RegulationConfigTable,
|
||||
ReiterSparteTable
|
||||
RegulationConfigTable
|
||||
)
|
||||
log.info("Masterdata database schema initialized successfully")
|
||||
}
|
||||
@@ -95,22 +96,26 @@ class MasterdataTestDatabaseConfiguration {
|
||||
transaction {
|
||||
SchemaUtils.create(
|
||||
LandTable,
|
||||
BundeslandTable,
|
||||
BundeslaenderTable,
|
||||
AltersklasseTable,
|
||||
PlatzTable,
|
||||
ReiterTable,
|
||||
HorseTable,
|
||||
VereinTable,
|
||||
FunktionaerTable,
|
||||
QualifikationMasterTable,
|
||||
FunktionaersQualifikationenTable,
|
||||
FunktionaerQualifikationTable,
|
||||
ReiterLizenzTable,
|
||||
TurnierklasseTable,
|
||||
ReitLizenzenTable,
|
||||
FahrLizenzenTable,
|
||||
StartkartenTable,
|
||||
ReiterLizenzenZuordnungTable,
|
||||
TurnierKlassenTable,
|
||||
TurnierSpartenTable,
|
||||
TurnierKategorienTable,
|
||||
LicenseTable,
|
||||
RichtverfahrenTable,
|
||||
GebuehrTable,
|
||||
RegulationConfigTable,
|
||||
ReiterSparteTable
|
||||
RegulationConfigTable
|
||||
)
|
||||
log.info("Test masterdata database schema initialized successfully")
|
||||
}
|
||||
|
||||
+164
@@ -0,0 +1,164 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.BundeslaenderTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.LandTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.ReiterTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.jetbrains.exposed.v1.jdbc.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Nationen (Länder) und Bundesländer.
|
||||
* Stellt sicher, dass die für den ZNS-Import notwendigen Masterdaten vorhanden sind.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class MasterdataSeeder {
|
||||
private val log = LoggerFactory.getLogger(MasterdataSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Master-Daten (Länder & Bundesländer)...")
|
||||
transaction {
|
||||
seedCountries()
|
||||
seedAustrianBundeslaender()
|
||||
fixReiterForeignKeys()
|
||||
}
|
||||
log.info("Seeding der Master-Daten abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun fixReiterForeignKeys() {
|
||||
// Falls Reiter bereits importiert wurden, bevor die Masterdaten da waren,
|
||||
// versuchen wir hier die Verknüpfungen (FKs) zu heilen.
|
||||
log.info("Prüfe und korrigiere Reiter-Fremdschlüssel (Heilung)...")
|
||||
|
||||
// 1. Bundesland-Links heilen
|
||||
val states = BundeslaenderTable.selectAll().toList()
|
||||
states.forEach { row ->
|
||||
val bId = row[BundeslaenderTable.id]
|
||||
val bNr = row[BundeslaenderTable.bundeslandNr]
|
||||
if (bNr != null) {
|
||||
ReiterTable.update({ (ReiterTable.bundeslandNummer eq bNr) and (ReiterTable.bundeslandId.isNull()) }) {
|
||||
it[bundeslandId] = bId
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Nation-Links heilen (ISO-Alpha3 Lookup)
|
||||
val nations = LandTable.selectAll().toList()
|
||||
nations.forEach { row ->
|
||||
val nId = row[LandTable.id]
|
||||
val iso3 = row[LandTable.isoAlpha3Code]
|
||||
ReiterTable.update({ (ReiterTable.nation eq iso3) and (ReiterTable.nationId.isNull()) }) {
|
||||
it[nationId] = nId
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Verein-Links heilen (Lookup über Name)
|
||||
log.info("Heile Reiter-Vereins-Verknüpfungen via Name...")
|
||||
val vt = at.mocode.masterdata.infrastructure.persistence.verein.VereinTable
|
||||
val vereine = vt.selectAll().toList()
|
||||
vereine.forEach { row ->
|
||||
val vId = row[vt.id]
|
||||
val vName = row[vt.vereinName]
|
||||
ReiterTable.update({ (ReiterTable.vereinsName eq vName) and (ReiterTable.vereinId.isNull()) }) {
|
||||
it[vereinId] = vId
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedCountries() {
|
||||
val countries = listOf(
|
||||
// iso2, iso3, num, nameDe, nameEn, eu, ewr, sort
|
||||
listOf("AT", "AUT", "040", "Österreich", "Austria", true, true, 1),
|
||||
listOf("DE", "DEU", "276", "Deutschland", "Germany", true, true, 2),
|
||||
listOf("CH", "CHE", "756", "Schweiz", "Switzerland", false, false, 3),
|
||||
listOf("IT", "ITA", "380", "Italien", "Italy", true, true, 4),
|
||||
listOf("CZ", "CZE", "203", "Tschechien", "Czech Republic", true, true, 6),
|
||||
listOf("SK", "SVK", "703", "Slowakei", "Slovakia", true, true, 7),
|
||||
listOf("SI", "SVN", "705", "Slowenien", "Slovenia", true, true, 8),
|
||||
listOf("HU", "HUN", "348", "Ungarn", "Hungary", true, true, 9),
|
||||
listOf("LI", "LIE", "438", "Liechtenstein", "Liechtenstein", false, true, 11)
|
||||
)
|
||||
|
||||
countries.forEach { c ->
|
||||
val iso2 = c[0] as String
|
||||
val exists = LandTable.selectAll().where { LandTable.isoAlpha2Code eq iso2 }.any()
|
||||
if (!exists) {
|
||||
LandTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[isoAlpha2Code] = iso2
|
||||
it[isoAlpha3Code] = c[1] as String
|
||||
it[isoNumerischerCode] = c[2] as String
|
||||
it[nameDeutsch] = c[3] as String
|
||||
it[nameEnglisch] = c[4] as String
|
||||
it[istEuMitglied] = c[5] as Boolean
|
||||
it[istEwrMitglied] = c[6] as Boolean
|
||||
it[sortierReihenfolge] = c[7] as Int
|
||||
}
|
||||
log.debug("Land '{}' angelegt.", iso2)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedAustrianBundeslaender() {
|
||||
val austria = LandTable.selectAll().where { LandTable.isoAlpha2Code eq "AT" }.singleOrNull()
|
||||
if (austria == null) {
|
||||
log.error("Österreich (AT) nicht gefunden, überspringe Bundesland-Seeding.")
|
||||
return
|
||||
}
|
||||
val austriaId = austria[LandTable.id]
|
||||
|
||||
val states = listOf(
|
||||
// nr, name, kuerzel, oeps
|
||||
listOf(1, "Wien", "W", "09"),
|
||||
listOf(2, "Niederösterreich", "NÖ", "03"),
|
||||
listOf(3, "Burgenland", "BGLD", "01"),
|
||||
listOf(4, "Steiermark", "STMK", "06"),
|
||||
listOf(5, "Kärnten", "KTN", "02"),
|
||||
listOf(6, "Oberösterreich", "OÖ", "04"),
|
||||
listOf(7, "Salzburg", "SBG", "05"),
|
||||
listOf(8, "Tirol", "T", "07"),
|
||||
listOf(9, "Vorarlberg", "VBG", "08"),
|
||||
listOf(0, "Unbekannt", "UNK", "00")
|
||||
)
|
||||
|
||||
states.forEach { s ->
|
||||
val nr = s[0] as Int
|
||||
val name = s[1] as String
|
||||
val kuerzel = s[2] as String
|
||||
val oeps = s[3] as String
|
||||
|
||||
val exists = BundeslaenderTable.selectAll().where {
|
||||
(BundeslaenderTable.landId eq austriaId) and (BundeslaenderTable.bundeslandNr eq nr)
|
||||
}.any()
|
||||
|
||||
if (!exists) {
|
||||
BundeslaenderTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[landId] = austriaId
|
||||
it[bundeslandNr] = nr
|
||||
it[BundeslaenderTable.name] = name
|
||||
it[BundeslaenderTable.kuerzel] = kuerzel
|
||||
it[oepsCode] = oeps
|
||||
}
|
||||
log.debug("Bundesland '{}' (Nr. {}) angelegt.", name, nr)
|
||||
} else {
|
||||
// Update falls vorhanden (Harmonisierung)
|
||||
BundeslaenderTable.update({ (BundeslaenderTable.landId eq austriaId) and (BundeslaenderTable.bundeslandNr eq nr) }) {
|
||||
it[BundeslaenderTable.name] = name
|
||||
it[BundeslaenderTable.kuerzel] = kuerzel
|
||||
it[oepsCode] = oeps
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
-86
@@ -1,86 +0,0 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.funktionaer.QualifikationMasterTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.jetbrains.exposed.v1.jdbc.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für die offiziellen ÖTO/FEI Qualifikations-Kürzel.
|
||||
* Befüllt die QualifikationMasterTable mit Standard-Werten.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class QualifikationMasterSeeder {
|
||||
private val log = LoggerFactory.getLogger(QualifikationMasterSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Qualifikations-Master-Daten (ÖTO/FEI)...")
|
||||
transaction {
|
||||
seedRichter()
|
||||
seedParcoursbauer()
|
||||
}
|
||||
log.info("Seeding der Qualifikations-Master-Daten abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun seedRichter() {
|
||||
val richterQualis = listOf(
|
||||
"D" to "Dressur",
|
||||
"S" to "Springen",
|
||||
"DPF" to "Dressurpferde",
|
||||
"SPF" to "Springpferde",
|
||||
"G" to "Gelände",
|
||||
"STW" to "Steward",
|
||||
"DM" to "Dressur Master",
|
||||
"SM" to "Springen Master",
|
||||
"GA" to "Grundausbildung",
|
||||
"G3" to "Gruppe 3",
|
||||
"G2" to "Gruppe 2",
|
||||
"G1" to "Gruppe 1"
|
||||
)
|
||||
|
||||
richterQualis.forEach { (code, bezeichnung) ->
|
||||
upsertQuali(code, bezeichnung, "RICHTER")
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedParcoursbauer() {
|
||||
val pbQualis = listOf(
|
||||
"P1" to "Einsteiger",
|
||||
"P2" to "Fortgeschritten",
|
||||
"P3" to "National",
|
||||
"P4" to "Grand Prix",
|
||||
"SP" to "Springen",
|
||||
"VS" to "Vielseitigkeit"
|
||||
)
|
||||
|
||||
pbQualis.forEach { (code, bezeichnung) ->
|
||||
upsertQuali(code, bezeichnung, "PARCOURSBAUER")
|
||||
}
|
||||
}
|
||||
|
||||
private fun upsertQuali(code: String, bezeichnung: String, typ: String) {
|
||||
val exists = QualifikationMasterTable.selectAll()
|
||||
.where { (QualifikationMasterTable.code eq code) and (QualifikationMasterTable.typ eq typ) }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
QualifikationMasterTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[QualifikationMasterTable.code] = code
|
||||
it[QualifikationMasterTable.bezeichnung] = bezeichnung
|
||||
it[QualifikationMasterTable.typ] = typ
|
||||
}
|
||||
log.debug("QualifikationMaster '{}' ({}) angelegt.", code, typ)
|
||||
}
|
||||
}
|
||||
}
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.FahrLizenzenTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.StartkartenTable
|
||||
import at.mocode.masterdata.infrastructure.persistence.reiter.ReitLizenzenTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Reit-Lizenzen, Fahr-Lizenzen und Startkarten.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class ReitLizenzenSeeder {
|
||||
private val log = LoggerFactory.getLogger(ReitLizenzenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Lizenzen...")
|
||||
transaction {
|
||||
seedReitLizenzen()
|
||||
seedFahrLizenzen()
|
||||
seedStartkarten()
|
||||
}
|
||||
log.info("Seeding der Lizenzen abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun seedReitLizenzen() {
|
||||
val lizenzen = listOf(
|
||||
Triple("R1", "Reitlizenz R1", "SPRINGEN"),
|
||||
Triple("RD1", "Reitlizenz RD1", "DRESSUR"),
|
||||
Triple("RD2", "Reitlizenz RD2", "DRESSUR"),
|
||||
Triple("RS2", "Reitlizenz RS2", "SPRINGEN")
|
||||
)
|
||||
lizenzen.forEach { (code, bez, sparte) ->
|
||||
if (ReitLizenzenTable.selectAll().where { ReitLizenzenTable.code eq code }.none()) {
|
||||
ReitLizenzenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[ReitLizenzenTable.code] = code
|
||||
it[bezeichnung] = bez
|
||||
it[ReitLizenzenTable.sparte] = sparte
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedFahrLizenzen() {
|
||||
val lizenzen = listOf(
|
||||
Pair("F1", "Fahrlizenz F1"),
|
||||
Pair("F2", "Fahrlizenz F2")
|
||||
)
|
||||
lizenzen.forEach { (code, bez) ->
|
||||
if (FahrLizenzenTable.selectAll().where { FahrLizenzenTable.code eq code }.none()) {
|
||||
FahrLizenzenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[FahrLizenzenTable.code] = code
|
||||
it[bezeichnung] = bez
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedStartkarten() {
|
||||
val karten = listOf(
|
||||
Pair("S1", "Startkarte S1"),
|
||||
Pair("S2", "Startkarte S2")
|
||||
)
|
||||
karten.forEach { (code, bez) ->
|
||||
if (StartkartenTable.selectAll().where { StartkartenTable.code eq code }.none()) {
|
||||
StartkartenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[StartkartenTable.code] = code
|
||||
it[bezeichnung] = bez
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.TurnierKategorienTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Turnier-Kategorien (z.B. CSN-C, CDN-A).
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class TurnierKategorienSeeder {
|
||||
private val log = LoggerFactory.getLogger(TurnierKategorienSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Turnier-Kategorien...")
|
||||
transaction {
|
||||
val kategorien = listOf(
|
||||
Triple("CSN-C", "Nationales Springturnier Kategorie C", "SPRINGEN"),
|
||||
Triple("CSN-C Neu", "Nationales Springturnier Kategorie C Neu", "SPRINGEN"),
|
||||
Triple("CSN-B", "Nationales Springturnier Kategorie B", "SPRINGEN"),
|
||||
Triple("CSN-A", "Nationales Springturnier Kategorie A", "SPRINGEN"),
|
||||
Triple("CDN-C", "Nationales Dressurturnier Kategorie C", "DRESSUR"),
|
||||
Triple("CDN-B", "Nationales Dressurturnier Kategorie B", "DRESSUR"),
|
||||
Triple("CDN-A", "Nationales Dressurturnier Kategorie A", "DRESSUR")
|
||||
)
|
||||
|
||||
kategorien.forEach { (code, bez, sparte) ->
|
||||
if (TurnierKategorienTable.selectAll().where { TurnierKategorienTable.code eq code }.none()) {
|
||||
TurnierKategorienTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[TurnierKategorienTable.code] = code
|
||||
it[bezeichnung] = bez
|
||||
it[TurnierKategorienTable.sparte] = sparte
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.TurnierKlassenTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Turnierklassen (z.B. E, A, L, M, S) gemäß ÖTO.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class TurnierKlassenSeeder {
|
||||
private val log = LoggerFactory.getLogger(TurnierKlassenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Turnierklassen...")
|
||||
transaction {
|
||||
seedSpringenKlassen()
|
||||
seedDressurKlassen()
|
||||
}
|
||||
log.info("Seeding der Turnierklassen abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun seedSpringenKlassen() {
|
||||
val klassen = listOf(
|
||||
Triple("E", "Einsteiger", 80),
|
||||
Triple("A", "Anfänger", 105),
|
||||
Triple("L", "Leicht", 115),
|
||||
Triple("LM", "Leicht-Mittel", 125),
|
||||
Triple("M", "Mittelschwer", 135),
|
||||
Triple("S", "Schwer", 150)
|
||||
)
|
||||
klassen.forEach { (code, bez, hoehe) ->
|
||||
upsertKlasse("SPRINGEN", code, bez, hoehe, null)
|
||||
}
|
||||
}
|
||||
|
||||
private fun seedDressurKlassen() {
|
||||
val klassen = listOf(
|
||||
Triple("E", "Einsteiger", "Aufgaben E"),
|
||||
Triple("A", "Anfänger", "Aufgaben A"),
|
||||
Triple("L", "Leicht", "Aufgaben L"),
|
||||
Triple("LM", "Leicht-Mittel", "Aufgaben LM"),
|
||||
Triple("M", "Mittelschwer", "Aufgaben M"),
|
||||
Triple("S", "Schwer", "Aufgaben S")
|
||||
)
|
||||
klassen.forEach { (code, bez, niveau) ->
|
||||
upsertKlasse("DRESSUR", code, bez, null, niveau)
|
||||
}
|
||||
}
|
||||
|
||||
private fun upsertKlasse(sparte: String, code: String, bezeichnung: String, hoehe: Int?, niveau: String?) {
|
||||
val exists = TurnierKlassenTable.selectAll()
|
||||
.where { (TurnierKlassenTable.sparte eq sparte) and (TurnierKlassenTable.code eq code) }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
TurnierKlassenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[TurnierKlassenTable.sparte] = sparte
|
||||
it[TurnierKlassenTable.code] = code
|
||||
it[TurnierKlassenTable.bezeichnung] = bezeichnung
|
||||
it[TurnierKlassenTable.maxHoehe] = hoehe
|
||||
it[TurnierKlassenTable.aufgabenNiveau] = niveau
|
||||
}
|
||||
log.debug("Turnierklasse '{}' ({}) angelegt.", code, sparte)
|
||||
}
|
||||
}
|
||||
}
|
||||
+60
@@ -0,0 +1,60 @@
|
||||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.masterdata.service.config
|
||||
|
||||
import at.mocode.masterdata.infrastructure.persistence.TurnierSpartenTable
|
||||
import jakarta.annotation.PostConstruct
|
||||
import org.jetbrains.exposed.v1.jdbc.transactions.transaction
|
||||
import org.jetbrains.exposed.v1.jdbc.insert
|
||||
import org.jetbrains.exposed.v1.jdbc.selectAll
|
||||
import org.jetbrains.exposed.v1.core.*
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.DependsOn
|
||||
import org.springframework.context.annotation.Profile
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
/**
|
||||
* Seeder für Turnier-Sparten (z.B. Dressur, Springen, Vielseitigkeit) gemäß ÖTO.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
@DependsOn("masterdataDatabaseConfiguration")
|
||||
class TurnierSpartenSeeder {
|
||||
private val log = LoggerFactory.getLogger(TurnierSpartenSeeder::class.java)
|
||||
|
||||
@PostConstruct
|
||||
fun seed() {
|
||||
log.info("Starte Seeding der Turnier-Sparten...")
|
||||
transaction {
|
||||
val sparten = listOf(
|
||||
"D" to "Dressur",
|
||||
"S" to "Springen",
|
||||
"V" to "Vielseitigkeit",
|
||||
"F" to "Fahren",
|
||||
"R" to "Reiten",
|
||||
"C" to "Voltigieren",
|
||||
"W" to "Western",
|
||||
"O" to "Orientierungsreiten"
|
||||
)
|
||||
sparten.forEach { (code, bezeichnung) ->
|
||||
upsertSparte(code, bezeichnung)
|
||||
}
|
||||
}
|
||||
log.info("Seeding der Turnier-Sparten abgeschlossen.")
|
||||
}
|
||||
|
||||
private fun upsertSparte(code: String, bezeichnung: String) {
|
||||
val exists = TurnierSpartenTable.selectAll()
|
||||
.where { TurnierSpartenTable.code eq code }
|
||||
.any()
|
||||
|
||||
if (!exists) {
|
||||
TurnierSpartenTable.insert {
|
||||
it[id] = Uuid.random()
|
||||
it[TurnierSpartenTable.code] = code
|
||||
it[TurnierSpartenTable.bezeichnung] = bezeichnung
|
||||
}
|
||||
log.debug("Turnier-Sparte '{}' angelegt.", bezeichnung)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -11,10 +11,24 @@ spring:
|
||||
flyway:
|
||||
enabled: true
|
||||
baseline-on-migrate: true
|
||||
cloud:
|
||||
consul:
|
||||
host: ${SPRING_CLOUD_CONSUL_HOST:localhost}
|
||||
port: ${SPRING_CLOUD_CONSUL_PORT:8500}
|
||||
enabled: ${CONSUL_ENABLED:true}
|
||||
discovery:
|
||||
enabled: ${CONSUL_ENABLED:true}
|
||||
register: ${CONSUL_ENABLED:true}
|
||||
health-check-path: /actuator/health
|
||||
health-check-interval: 10s
|
||||
health-check-port: 8086
|
||||
instance-id: ${spring.application.name}-${server.port}-${random.uuid}
|
||||
service-name: ${spring.application.name}
|
||||
port: 8091
|
||||
|
||||
server:
|
||||
port: 8086 # Spring Boot Management Port (Actuator & Tomcat)
|
||||
address: 127.0.0.1 # Sicherheit: Nur lokal erreichbar
|
||||
address: 0.0.0.0 # Erreichbar für Consul Health Checks
|
||||
|
||||
masterdata:
|
||||
http:
|
||||
|
||||
+45
@@ -0,0 +1,45 @@
|
||||
-- V013__Cleanup_and_Standardize_Masterdata.sql
|
||||
-- Datum: 6. April 2026
|
||||
|
||||
-- 1. Bundesland -> bundeslaender
|
||||
ALTER TABLE bundesland RENAME TO bundeslaender;
|
||||
ALTER TABLE bundeslaender RENAME COLUMN id TO bundesland_id;
|
||||
ALTER INDEX IF EXISTS pk_bundesland RENAME TO pk_bundeslaender;
|
||||
ALTER INDEX IF EXISTS idx_bundesland_oeps RENAME TO idx_bundeslaender_oeps;
|
||||
ALTER INDEX IF EXISTS idx_bundesland_iso RENAME TO idx_bundeslaender_iso;
|
||||
ALTER INDEX IF EXISTS ux_bundesland_land_kuerzel RENAME TO ux_bundeslaender_land_kuerzel;
|
||||
ALTER INDEX IF EXISTS bundesland_bundesland_nr_unique RENAME TO bundeslaender_bundesland_nr_unique;
|
||||
|
||||
-- 2. qualifikation_master -> funktionaers_qualifikationen
|
||||
ALTER TABLE qualifikation_master RENAME TO funktionaers_qualifikationen;
|
||||
-- Die Join-Tabelle funktionaer_qualifikation bleibt als solche bestehen,
|
||||
-- referenziert aber nun funktionaers_qualifikationen.
|
||||
-- (Der Name der Join-Tabelle ist bereits fast korrekt, wir lassen sie vorerst so,
|
||||
-- da sie die Verknüpfung zw. Funktionär und Qualifikation darstellt.)
|
||||
-- Update: Der User möchte "funktionaers_qualifikationen" als Name für die Qualifikationen.
|
||||
|
||||
-- 3. reiter_lizenz -> reit_lizenzen
|
||||
ALTER TABLE reiter_lizenz RENAME TO reit_lizenzen;
|
||||
ALTER INDEX IF EXISTS pk_reiter_lizenz RENAME TO pk_reit_lizenzen;
|
||||
|
||||
-- 4. reiter_sparte entfernen
|
||||
DROP TABLE IF EXISTS reiter_sparte;
|
||||
|
||||
-- 5. turnierklasse -> turnier_klassen
|
||||
ALTER TABLE turnierklasse RENAME TO turnier_klassen;
|
||||
ALTER INDEX IF EXISTS pk_turnierklasse RENAME TO pk_turnier_klassen;
|
||||
ALTER INDEX IF EXISTS idx_turnierklasse_sparte_code RENAME TO idx_turnier_klassen_sparte_code;
|
||||
|
||||
-- 6. turnier_sparten erstellen
|
||||
CREATE TABLE IF NOT EXISTS turnier_sparten (
|
||||
sparte_id UUID PRIMARY KEY,
|
||||
code VARCHAR(10) UNIQUE NOT NULL, -- z.B. D, S, V, F, R, C
|
||||
bezeichnung VARCHAR(100) NOT NULL, -- z.B. Dressur, Springen, Vielseitigkeit, Fahren, Reiten, Voltigieren
|
||||
ist_aktiv BOOLEAN DEFAULT true,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
-- 7. Constraints aktualisieren (falls nötig)
|
||||
-- Da wir nur Tabellen umbenannt haben, bleiben die Foreign Keys in PostgreSQL erhalten
|
||||
-- und zeigen automatisch auf die neuen Tabellennamen.
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
-- V014__Expand_Masterdata_Rider_and_Competitions.sql
|
||||
-- Datum: 6. April 2026
|
||||
|
||||
-- 1. altersklasse -> altersklassen
|
||||
ALTER TABLE altersklasse RENAME TO altersklassen;
|
||||
ALTER INDEX IF EXISTS pk_altersklasse RENAME TO pk_altersklassen;
|
||||
ALTER INDEX IF EXISTS idx_altersklasse_aktiv RENAME TO idx_altersklassen_aktiv;
|
||||
ALTER INDEX IF EXISTS idx_altersklasse_sparte RENAME TO idx_altersklassen_sparte;
|
||||
ALTER INDEX IF EXISTS idx_altersklasse_geschlecht RENAME TO idx_altersklassen_geschlecht;
|
||||
ALTER INDEX IF EXISTS idx_altersklasse_alter RENAME TO idx_altersklassen_alter;
|
||||
|
||||
-- 2. turnier_klassen -> bewerbs_klassen
|
||||
ALTER TABLE turnier_klassen RENAME TO bewerbs_klassen;
|
||||
ALTER TABLE bewerbs_klassen RENAME COLUMN turnierklasse_id TO bewerbsklasse_id;
|
||||
ALTER INDEX IF EXISTS pk_turnier_klassen RENAME TO pk_bewerbs_klassen;
|
||||
ALTER INDEX IF EXISTS idx_turnier_klassen_sparte_code RENAME TO idx_bewerbs_klassen_sparte_code;
|
||||
|
||||
-- 3. turnier_kategorien erstellen
|
||||
CREATE TABLE IF NOT EXISTS turnier_kategorien (
|
||||
kategorie_id UUID PRIMARY KEY,
|
||||
code VARCHAR(20) UNIQUE NOT NULL, -- z.B. CSN-C, CDN-A, CSN-C Neu
|
||||
bezeichnung VARCHAR(100) NOT NULL,
|
||||
sparte VARCHAR(20), -- SPRINGEN, DRESSUR, etc.
|
||||
ist_aktiv BOOLEAN DEFAULT true,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
-- 4. reit_lizenzen anpassen: Ein Reiter hat 0..1 Reit-Lizenz (Kürzel wie R1, RD1, etc.)
|
||||
-- Die bestehende Tabelle reit_lizenzen (Join-Tabelle/Mehrfach) wird hier
|
||||
-- beibehalten für fachspezifische Detail-Lizenzen, aber wir fügen
|
||||
-- in der Reiter-Tabelle direkte Spalten für die Haupt-Lizenzen hinzu.
|
||||
-- Fahr-Lizenzen und Startkarten ebenfalls als 0..1 Spalten beim Reiter.
|
||||
|
||||
ALTER TABLE reiter ADD COLUMN IF NOT EXISTS fahr_lizenz_id UUID;
|
||||
ALTER TABLE reiter ADD COLUMN IF NOT EXISTS startkarte_id UUID;
|
||||
|
||||
-- 5. fahr_lizenzen Master-Tabelle
|
||||
CREATE TABLE IF NOT EXISTS fahr_lizenzen (
|
||||
lizenz_id UUID PRIMARY KEY,
|
||||
code VARCHAR(20) UNIQUE NOT NULL, -- z.B. F1, F2
|
||||
bezeichnung VARCHAR(100) NOT NULL,
|
||||
ist_aktiv BOOLEAN DEFAULT true,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
-- 6. startkarten Master-Tabelle
|
||||
CREATE TABLE IF NOT EXISTS startkarten (
|
||||
startkarte_id UUID PRIMARY KEY,
|
||||
code VARCHAR(20) UNIQUE NOT NULL, -- z.B. S1, S2
|
||||
bezeichnung VARCHAR(100) NOT NULL,
|
||||
ist_aktiv BOOLEAN DEFAULT true,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
-- 7. reit_lizenzen (Master-Tabelle für Kürzel-Definitionen)
|
||||
-- Wir hatten reit_lizenzen als Join-Tabelle definiert in V013.
|
||||
-- Wir behalten reit_lizenzen als Join-Tabelle (reiter_id, kuerzel) bei,
|
||||
-- aber fügen eine Master-Tabelle für die Kürzel selbst hinzu.
|
||||
-- Umbenennung der in V013 erstellten reit_lizenzen zu reiter_lizenzen_zuordnung
|
||||
ALTER TABLE reit_lizenzen RENAME TO reiter_lizenzen_zuordnung;
|
||||
|
||||
CREATE TABLE IF NOT EXISTS reit_lizenzen (
|
||||
lizenz_id UUID PRIMARY KEY,
|
||||
code VARCHAR(20) UNIQUE NOT NULL, -- z.B. R1, RD1, RS2
|
||||
bezeichnung VARCHAR(100) NOT NULL,
|
||||
sparte VARCHAR(20), -- SPRINGEN, DRESSUR, VIELSEITIGKEIT
|
||||
ist_aktiv BOOLEAN DEFAULT true,
|
||||
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
-- 8. Fremdschlüssel für Reiter Tabelle aktualisieren
|
||||
ALTER TABLE reiter ADD CONSTRAINT fk_reiter_fahr_lizenz FOREIGN KEY (fahr_lizenz_id) REFERENCES fahr_lizenzen(lizenz_id);
|
||||
ALTER TABLE reiter ADD CONSTRAINT fk_reiter_startkarte FOREIGN KEY (startkarte_id) REFERENCES startkarten(startkarte_id);
|
||||
-- reit_lizenz_id hinzufügen für 0..1 Beziehung
|
||||
ALTER TABLE reiter ADD COLUMN IF NOT EXISTS reit_lizenz_id UUID;
|
||||
ALTER TABLE reiter ADD CONSTRAINT fk_reiter_reit_lizenz FOREIGN KEY (reit_lizenz_id) REFERENCES reit_lizenzen(lizenz_id);
|
||||
Reference in New Issue
Block a user