Remove Dom prefix from domain models: delete DomVeranstaltung, rename models like DomNennung to Nennung, update references in repositories, services, and tests for consistency.

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungRepositoryImpl.kt

@@ -4,7 +4,7 @@ package at.mocode.entries.service.persistence
 
 import at.mocode.core.domain.model.NennStatusE
 import at.mocode.core.domain.model.StartwunschE
-import at.mocode.entries.domain.model.DomNennung
+import at.mocode.entries.domain.model.Nennung
 import at.mocode.entries.domain.repository.NennungRepository
 import org.jetbrains.exposed.v1.core.ResultRow
 import org.jetbrains.exposed.v1.core.and
@@ -24,7 +24,7 @@ import kotlin.uuid.toKotlinUuid
  */
 class NennungRepositoryImpl : NennungRepository {
 
-  private fun rowToNennung(row: ResultRow): DomNennung = DomNennung(
+  private fun rowToNennung(row: ResultRow): Nennung = Nennung(
     nennungId = row[NennungTable.id].toKotlinUuid(),
     abteilungId = row[NennungTable.abteilungId].toKotlinUuid(),
     bewerbId = row[NennungTable.bewerbId].toKotlinUuid(),
@@ -41,57 +41,57 @@ class NennungRepositoryImpl : NennungRepository {
     updatedAt = row[NennungTable.updatedAt]
   )
 
-  override suspend fun findById(id: Uuid): DomNennung? = tenantTransaction {
+  override suspend fun findById(id: Uuid): Nennung? = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.id eq id.toJavaUuid() }
       .map(::rowToNennung)
       .singleOrNull()
   }
 
-  override suspend fun findByBewerbId(bewerbId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByBewerbId(bewerbId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.bewerbId eq bewerbId.toJavaUuid() }
       .map(::rowToNennung)
   }
 
-  override suspend fun findByAbteilungId(abteilungId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByAbteilungId(abteilungId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.abteilungId eq abteilungId.toJavaUuid() }
       .map(::rowToNennung)
   }
 
-  override suspend fun findByTurnierId(turnierId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByTurnierId(turnierId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.turnierId eq turnierId.toJavaUuid() }
       .map(::rowToNennung)
   }
 
-  override suspend fun findByReiterId(reiterId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByReiterId(reiterId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.reiterId eq reiterId.toJavaUuid() }
       .map(::rowToNennung)
   }
 
-  override suspend fun findByPferdId(pferdId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByPferdId(pferdId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.pferdId eq pferdId.toJavaUuid() }
       .map(::rowToNennung)
   }
 
-  override suspend fun findByReiterIdAndTurnierId(reiterId: Uuid, turnierId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findByReiterIdAndTurnierId(reiterId: Uuid, turnierId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where {
       (NennungTable.reiterId eq reiterId.toJavaUuid()) and
         (NennungTable.turnierId eq turnierId.toJavaUuid())
     }.map(::rowToNennung)
   }
 
-  override suspend fun findByStatus(status: NennStatusE): List<DomNennung> = tenantTransaction {
+  override suspend fun findByStatus(status: NennStatusE): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where { NennungTable.status eq status.name }
       .map(::rowToNennung)
   }
 
-  override suspend fun findNachnennungenByBewerbId(bewerbId: Uuid): List<DomNennung> = tenantTransaction {
+  override suspend fun findNachnennungenByBewerbId(bewerbId: Uuid): List<Nennung> = tenantTransaction {
     NennungTable.selectAll().where {
       (NennungTable.bewerbId eq bewerbId.toJavaUuid()) and
         (NennungTable.istNachnennung eq true)
     }.map(::rowToNennung)
   }
 
-  override suspend fun save(nennung: DomNennung): DomNennung = tenantTransaction {
+  override suspend fun save(nennung: Nennung): Nennung = tenantTransaction {
     val now = Clock.System.now()
     val existing = NennungTable.selectAll()
       .where { NennungTable.id eq nennung.nennungId.toJavaUuid() }

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/persistence/NennungsTransferRepositoryImpl.kt

@@ -2,7 +2,7 @@
 
 package at.mocode.entries.service.persistence
 
-import at.mocode.entries.domain.model.DomNennungsTransfer
+import at.mocode.entries.domain.model.NennungsTransfer
 import at.mocode.entries.domain.repository.NennungsTransferRepository
 import org.jetbrains.exposed.v1.core.ResultRow
 import org.jetbrains.exposed.v1.core.eq
@@ -19,7 +19,7 @@ import kotlin.uuid.toKotlinUuid
  */
 class NennungsTransferRepositoryImpl : NennungsTransferRepository {
 
-  private fun rowToTransfer(row: ResultRow): DomNennungsTransfer = DomNennungsTransfer(
+  private fun rowToTransfer(row: ResultRow): NennungsTransfer = NennungsTransfer(
     transferId = row[NennungsTransferTable.id].toKotlinUuid(),
     ursprungsNennungId = row[NennungsTransferTable.ursprungsNennungId].toKotlinUuid(),
     neueNennungId = row[NennungsTransferTable.neueNennungId].toKotlinUuid(),
@@ -34,19 +34,19 @@ class NennungsTransferRepositoryImpl : NennungsTransferRepository {
     createdAt = row[NennungsTransferTable.createdAt]
   )
 
-  override suspend fun findById(id: Uuid): DomNennungsTransfer? = tenantTransaction {
+  override suspend fun findById(id: Uuid): NennungsTransfer? = tenantTransaction {
     NennungsTransferTable.selectAll().where { NennungsTransferTable.id eq id.toJavaUuid() }
       .map(::rowToTransfer)
       .singleOrNull()
   }
 
-  override suspend fun findByUrsprungsNennungId(nennungId: Uuid): List<DomNennungsTransfer> = tenantTransaction {
+  override suspend fun findByUrsprungsNennungId(nennungId: Uuid): List<NennungsTransfer> = tenantTransaction {
     NennungsTransferTable.selectAll()
       .where { NennungsTransferTable.ursprungsNennungId eq nennungId.toJavaUuid() }
       .map(::rowToTransfer)
   }
 
-  override suspend fun save(transfer: DomNennungsTransfer): DomNennungsTransfer = tenantTransaction {
+  override suspend fun save(transfer: NennungsTransfer): NennungsTransfer = tenantTransaction {
     val now = Clock.System.now()
     NennungsTransferTable.insert { stmt ->
       stmt[id] = transfer.transferId.toJavaUuid()

backend/services/entries/entries-service/src/main/kotlin/at/mocode/entries/service/usecase/NennungUseCases.kt

@@ -4,8 +4,8 @@ package at.mocode.entries.service.usecase
 
 import at.mocode.core.domain.model.NennStatusE
 import at.mocode.entries.api.*
-import at.mocode.entries.domain.model.DomNennung
-import at.mocode.entries.domain.model.DomNennungsTransfer
+import at.mocode.entries.domain.model.Nennung
+import at.mocode.entries.domain.model.NennungsTransfer
 import at.mocode.entries.domain.repository.NennungRepository
 import at.mocode.entries.domain.repository.NennungsTransferRepository
 import org.slf4j.LoggerFactory
@@ -61,7 +61,7 @@ class NennungUseCases(
         request.turnierId, request.bewerbId, request.reiterId
       )
     }
-    val nennung = DomNennung(
+    val nennung = Nennung(
       abteilungId = request.abteilungId,
       bewerbId = request.bewerbId,
       turnierId = request.turnierId,
@@ -135,7 +135,7 @@ class NennungUseCases(
     nennungRepository.save(geschlosseneNennung)
 
     // 2. Neue Nennung anlegen
-    val neueNennung = DomNennung(
+    val neueNennung = Nennung(
       abteilungId = ursprung.abteilungId,
       bewerbId = ursprung.bewerbId,
       turnierId = ursprung.turnierId,
@@ -150,7 +150,7 @@ class NennungUseCases(
     val gespeicherteNeueNennung = nennungRepository.save(neueNennung)
 
     // 3. Transfer-Record speichern
-    val transfer = DomNennungsTransfer(
+    val transfer = NennungsTransfer(
       ursprungsNennungId = ursprung.nennungId,
       neueNennungId = gespeicherteNeueNennung.nennungId,
       alterReiterId = if (request.neuerReiterId != null) ursprung.reiterId else null,
@@ -175,7 +175,7 @@ class NennungUseCases(
   // Mapping Helpers
   // ---------------------------------------------------------------------------
 
-  private fun DomNennung.toDetailDto() = NennungDetailDto(
+  private fun Nennung.toDetailDto() = NennungDetailDto(
     nennungId = nennungId,
     abteilungId = abteilungId,
     bewerbId = bewerbId,
@@ -193,7 +193,7 @@ class NennungUseCases(
     updatedAt = updatedAt.toString()
   )
 
-  private fun DomNennung.toSummaryDto() = NennungSummaryDto(
+  private fun Nennung.toSummaryDto() = NennungSummaryDto(
     nennungId = nennungId,
     turnierId = turnierId,
     bewerbId = bewerbId,
@@ -205,7 +205,7 @@ class NennungUseCases(
     createdAt = createdAt.toString()
   )
 
-  private fun DomNennungsTransfer.toDto() = NennungsTransferDto(
+  private fun NennungsTransfer.toDto() = NennungsTransferDto(
     transferId = transferId,
     ursprungsNennungId = ursprungsNennungId,
     neueNennungId = neueNennungId,