feat(horses-service): remove legacy configuration and repository classes

- Deleted outdated `ApplicationConfiguration` and `HorseRepositoryImpl` classes.
- Migrated to streamlined modular Gradle configuration in `build.gradle.kts`.
- Updated domain models and dependencies to use multiplatform and serialization plugins.
- Added modular setup for `horses` namespace in `settings.gradle.kts`.
- Reorganized database configuration with minimal JDBC bindings for development.

Signed-off-by: Stefan Mogeritsch <stefan.mo.co@gmail.com>

backend/services/persons/persons-domain/build.gradle.kts

@@ -0,0 +1,26 @@
+plugins {
+  alias(libs.plugins.kotlinMultiplatform)
+  alias(libs.plugins.kotlinSerialization)
+}
+
+kotlin {
+  jvm()
+
+  sourceSets {
+    commonMain {
+      kotlin.srcDir("src/main/kotlin")
+      dependencies {
+        implementation(projects.core.coreDomain)
+        implementation(projects.core.coreUtils)
+        implementation(libs.kotlinx.datetime)
+        implementation(libs.kotlinx.serialization.json)
+      }
+    }
+    commonTest {
+      kotlin.srcDir("src/test/kotlin")
+      dependencies {
+        implementation(projects.platform.platformTesting)
+      }
+    }
+  }
+}

backend/services/persons/persons-domain/src/main/kotlin/at/mocode/persons/domain/model/DomPerson.kt

@@ -0,0 +1,58 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+
+package at.mocode.persons.domain.model
+
+import at.mocode.core.domain.model.DatenQuelleE
+import at.mocode.core.domain.serialization.KotlinInstantSerializer
+import at.mocode.core.domain.serialization.UuidSerializer
+import kotlinx.datetime.LocalDate
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+import kotlin.time.Instant
+import kotlin.uuid.Uuid
+
+/**
+ * Domain model representing a person (rider/member) in the registry system.
+ *
+ * @property personId Unique internal identifier (UUID).
+ * @property lizenzNummer ÖPS license number (from ZNS LIZENZ01.dat).
+ * @property nachname Last name.
+ * @property vorname First name.
+ * @property geschlecht Gender code (M/W).
+ * @property geburtsdatum Date of birth.
+ * @property nation Nation code (e.g. AUT).
+ * @property lizenzKlasse License class (e.g. R1, R2, RD2).
+ * @property mitgliedsNummer Membership number.
+ * @property vereinsNummer Club number.
+ * @property vereinsName Club name.
+ * @property datenQuelle Source of the data.
+ * @property createdAt Timestamp when this record was created.
+ * @property updatedAt Timestamp when this record was last updated.
+ */
+@Serializable
+data class DomPerson(
+  @Serializable(with = UuidSerializer::class)
+  val personId: Uuid = Uuid.random(),
+
+  val lizenzNummer: String,
+  val nachname: String,
+  val vorname: String,
+
+  val geschlecht: String? = null,
+  val geburtsdatum: LocalDate? = null,
+  val nation: String? = null,
+  val lizenzKlasse: String? = null,
+  val mitgliedsNummer: String? = null,
+  val vereinsNummer: String? = null,
+  val vereinsName: String? = null,
+
+  val istAktiv: Boolean = true,
+  val datenQuelle: DatenQuelleE = DatenQuelleE.IMPORT_ZNS,
+
+  @Serializable(with = KotlinInstantSerializer::class)
+  val createdAt: Instant = Clock.System.now(),
+  @Serializable(with = KotlinInstantSerializer::class)
+  var updatedAt: Instant = Clock.System.now()
+) {
+  fun getDisplayName(): String = "$vorname $nachname"
+}

backend/services/persons/persons-infrastructure/build.gradle.kts

@@ -0,0 +1,23 @@
+plugins {
+  alias(libs.plugins.kotlinJvm)
+  alias(libs.plugins.kotlinSpring)
+  alias(libs.plugins.kotlinSerialization)
+}
+
+dependencies {
+  implementation(projects.platform.platformDependencies)
+  implementation(projects.persons.personsDomain)
+  implementation(projects.core.coreDomain)
+  implementation(projects.core.coreUtils)
+
+  implementation(libs.spring.boot.starter.web)
+
+  implementation(libs.exposed.core)
+  implementation(libs.exposed.dao)
+  implementation(libs.exposed.jdbc)
+  implementation(libs.exposed.kotlin.datetime)
+
+  runtimeOnly(libs.postgresql.driver)
+
+  testImplementation(projects.platform.platformTesting)
+}

backend/services/persons/persons-infrastructure/src/main/kotlin/at/mocode/persons/infrastructure/persistence/ZnsPersonTable.kt

@@ -0,0 +1,23 @@
+package at.mocode.persons.infrastructure.persistence
+
+import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
+import org.jetbrains.exposed.v1.datetime.date
+import org.jetbrains.exposed.v1.datetime.timestamp
+
+/**
+ * Tabelle für importierte Personen/Reiter aus dem ZNS-Datenbestand (LIZENZ01.dat).
+ * Wird ausschließlich als Dev-Seed-Daten verwendet.
+ */
+object ZnsPersonTable : UUIDTable("zns_persons") {
+  val lizenzNummer = varchar("lizenz_nummer", 10).uniqueIndex()
+  val nachname = varchar("nachname", 50)
+  val vorname = varchar("vorname", 25)
+  val vereinsNummer = varchar("vereins_nummer", 4).nullable()
+  val vereinsName = varchar("vereins_name", 50).nullable()
+  val nation = varchar("nation", 3).nullable()
+  val lizenzKlasse = varchar("lizenz_klasse", 6).nullable()
+  val mitgliedsNummer = varchar("mitglieds_nummer", 13).nullable()
+  val geschlecht = varchar("geschlecht", 1).nullable()
+  val geburtsdatum = date("geburtsdatum").nullable()
+  val createdAt = timestamp("created_at")
+}

backend/services/persons/persons-service/build.gradle.kts

@@ -0,0 +1,38 @@
+plugins {
+  alias(libs.plugins.kotlinJvm)
+  alias(libs.plugins.kotlinSpring)
+  alias(libs.plugins.spring.boot)
+  alias(libs.plugins.spring.dependencyManagement)
+}
+
+springBoot {
+  mainClass.set("at.mocode.persons.service.PersonsServiceApplicationKt")
+}
+
+dependencies {
+  implementation(projects.platform.platformDependencies)
+  implementation(projects.core.coreDomain)
+  implementation(projects.core.coreUtils)
+  implementation(projects.persons.personsDomain)
+  implementation(projects.persons.personsInfrastructure)
+
+  implementation(libs.spring.boot.starter.web)
+  implementation(libs.spring.boot.starter.validation)
+  implementation(libs.spring.boot.starter.actuator)
+
+  implementation(libs.exposed.core)
+  implementation(libs.exposed.dao)
+  implementation(libs.exposed.jdbc)
+  implementation(libs.exposed.kotlin.datetime)
+  implementation(libs.hikari.cp)
+  runtimeOnly(libs.postgresql.driver)
+  testRuntimeOnly(libs.h2.driver)
+
+  testImplementation(projects.platform.platformTesting)
+  testImplementation(libs.spring.boot.starter.test)
+  testImplementation(libs.logback.classic)
+}
+
+tasks.test {
+  useJUnitPlatform()
+}

backend/services/persons/persons-service/src/main/kotlin/at/mocode/persons/service/PersonsServiceApplication.kt

@@ -0,0 +1,18 @@
+package at.mocode.persons.service
+
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.runApplication
+import org.springframework.context.annotation.ComponentScan
+
+@SpringBootApplication
+@ComponentScan(
+  basePackages = [
+    "at.mocode.persons.service",
+    "at.mocode.persons.infrastructure"
+  ]
+)
+class PersonsServiceApplication
+
+fun main(args: Array<String>) {
+  runApplication<PersonsServiceApplication>(*args)
+}

backend/services/persons/persons-service/src/main/kotlin/at/mocode/persons/service/config/DatabaseConfiguration.kt

@@ -0,0 +1,31 @@
+package at.mocode.persons.service.config
+
+import at.mocode.persons.infrastructure.persistence.ZnsPersonTable
+import jakarta.annotation.PostConstruct
+import org.jetbrains.exposed.v1.jdbc.Database
+import org.jetbrains.exposed.v1.jdbc.SchemaUtils
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Profile
+
+@Configuration
+@Profile("dev")
+class PersonsDatabaseConfiguration(
+  @Value("\${spring.datasource.url}") private val jdbcUrl: String,
+  @Value("\${spring.datasource.username}") private val username: String,
+  @Value("\${spring.datasource.password}") private val password: String
+) {
+  private val log = LoggerFactory.getLogger(PersonsDatabaseConfiguration::class.java)
+
+  @PostConstruct
+  fun initializeDatabase() {
+    log.info("Initialisiere Datenbank-Schema für Persons-Service...")
+    Database.connect(jdbcUrl, user = username, password = password)
+    transaction {
+      SchemaUtils.createMissingTablesAndColumns(ZnsPersonTable)
+      log.info("Datenbank-Schema erfolgreich initialisiert")
+    }
+  }
+}

backend/services/persons/persons-service/src/main/kotlin/at/mocode/persons/service/dev/ZnsPersonSeeder.kt

@@ -0,0 +1,136 @@
+package at.mocode.persons.service.dev
+
+import at.mocode.persons.infrastructure.persistence.ZnsPersonTable
+import org.jetbrains.exposed.v1.jdbc.SchemaUtils
+import org.jetbrains.exposed.v1.jdbc.batchInsert
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.boot.CommandLineRunner
+import org.springframework.context.annotation.Profile
+import org.springframework.stereotype.Component
+import java.io.File
+import kotlin.time.Clock
+
+/**
+ * Dev-only Seeder: Importiert LIZENZ01.dat (ZNS) → zns_persons.
+ * Aktivierung: Umgebungsvariable ZNS_DATA_DIR setzen + Profil "dev".
+ */
+@Component
+@Profile("dev")
+class ZnsPersonSeeder(
+  @Value("\${zns.data.dir:#{null}}") private val znsDataDir: String?
+) : CommandLineRunner {
+
+  private val log = LoggerFactory.getLogger(ZnsPersonSeeder::class.java)
+
+  override fun run(vararg args: String) {
+    if (znsDataDir == null) {
+      log.info("ZNS_DATA_DIR nicht gesetzt – ZnsPersonSeeder wird übersprungen.")
+      return
+    }
+    val dir = File(znsDataDir)
+    if (!dir.exists() || !dir.isDirectory) {
+      log.warn("ZNS_DATA_DIR '{}' existiert nicht oder ist kein Verzeichnis.", znsDataDir)
+      return
+    }
+    log.info("Starte ZNS-Personen-Import aus: {}", dir.absolutePath)
+    transaction {
+      SchemaUtils.createMissingTablesAndColumns(ZnsPersonTable)
+    }
+    seedPersons(dir)
+    log.info("ZNS-Personen-Import abgeschlossen.")
+  }
+
+  // -------------------------------------------------------------------------
+  // LIZENZ01.dat → zns_persons
+  // Format (220 Zeichen):
+  //   [0-5]    LizenzNr
+  //   [6-55]   Nachname
+  //   [56-80]  Vorname
+  //   [81-83]  VereinsNr
+  //   [84-133] VereinsName
+  //   [134-136] Nation
+  //   [137-143] LizenzKlasse (z.B. "R1", "R2", "RD2")
+  //   [144-156] MitgliedsNr
+  //   [157-165] Telefon (nicht gespeichert)
+  //   [166-169] Jahr
+  //   [170]    Geschlecht (M/W)
+  //   [171-178] Geburtsdatum (YYYYMMDD)
+  // -------------------------------------------------------------------------
+  private fun seedPersons(dir: File) {
+    val file = File(dir, "LIZENZ01.dat")
+    if (!file.exists()) {
+      log.warn("LIZENZ01.dat nicht gefunden – Personen werden übersprungen.")
+      return
+    }
+
+    data class PersonRow(
+      val lizenzNr: String,
+      val nachname: String,
+      val vorname: String,
+      val vereinsNr: String?,
+      val vereinsName: String?,
+      val nation: String?,
+      val lizenzKlasse: String?,
+      val mitgliedsNr: String?,
+      val geschlecht: String?,
+      val geburtsdatum: java.time.LocalDate?
+    )
+
+    val rows = file.readLines(Charsets.ISO_8859_1)
+      .filter { it.length >= 6 }
+      .mapNotNull { line ->
+        val lizenzNr = line.substring(0, 6).trim()
+        if (lizenzNr.isBlank()) return@mapNotNull null
+
+        val nachname = line.safeSubstring(6, 56).trim()
+        val vorname = line.safeSubstring(56, 81).trim()
+        val vereinsNr = line.safeSubstring(81, 84).trim().takeIf { it.isNotBlank() }
+        val vereinsName = line.safeSubstring(84, 134).trim().takeIf { it.isNotBlank() }
+        val nation = line.safeSubstring(134, 137).trim().takeIf { it.isNotBlank() }
+        val lizenzKlasse = line.safeSubstring(137, 144).trim().takeIf { it.isNotBlank() }
+        val mitgliedsNr = line.safeSubstring(144, 157).trim().takeIf { it.isNotBlank() }
+        val geschlecht = line.safeSubstring(170, 171).trim().takeIf { it.isNotBlank() }
+        val gebDatStr = line.safeSubstring(171, 179).trim()
+        val gebDat = parseDate(gebDatStr)
+
+        PersonRow(
+          lizenzNr, nachname, vorname, vereinsNr, vereinsName,
+          nation, lizenzKlasse, mitgliedsNr, geschlecht, gebDat
+        )
+      }
+
+    val now = Clock.System.now()
+    transaction {
+      ZnsPersonTable.batchInsert(rows, ignore = true) { row ->
+        this[ZnsPersonTable.lizenzNummer] = row.lizenzNr
+        this[ZnsPersonTable.nachname] = row.nachname
+        this[ZnsPersonTable.vorname] = row.vorname
+        this[ZnsPersonTable.vereinsNummer] = row.vereinsNr
+        this[ZnsPersonTable.vereinsName] = row.vereinsName
+        this[ZnsPersonTable.nation] = row.nation
+        this[ZnsPersonTable.lizenzKlasse] = row.lizenzKlasse
+        this[ZnsPersonTable.mitgliedsNummer] = row.mitgliedsNr
+        this[ZnsPersonTable.geschlecht] = row.geschlecht
+        this[ZnsPersonTable.geburtsdatum] = row.geburtsdatum?.let {
+          kotlinx.datetime.LocalDate(it.year, it.monthValue, it.dayOfMonth)
+        }
+        this[ZnsPersonTable.createdAt] = now
+      }
+    }
+    log.info("Personen importiert: {} Datensätze", rows.size)
+  }
+
+  private fun String.safeSubstring(start: Int, end: Int): String =
+    if (this.length >= end) this.substring(start, end) else if (this.length > start) this.substring(start) else ""
+
+  private fun parseDate(s: String): java.time.LocalDate? {
+    if (s.length < 8 || s.all { it == '0' }) return null
+    return try {
+      java.time.LocalDate.of(s.substring(0, 4).toInt(), s.substring(4, 6).toInt(), s.substring(6, 8).toInt())
+    } catch (_: Exception) {
+      null
+    }
+  }
+}