Register events modules in Gradle build and refactor VeranstaltungController: remove unused use cases, streamline request handling, and improve error responses.
This commit is contained in:
parent
df8bce4277
commit
8bc6f8e1df
|
|
@ -1,39 +1,32 @@
|
|||
plugins {
|
||||
alias(libs.plugins.kotlin.jvm)
|
||||
alias(libs.plugins.kotlin.spring)
|
||||
alias(libs.plugins.kotlin.serialization)
|
||||
alias(libs.plugins.ktor)
|
||||
application
|
||||
// KORREKTUR 1: Dieses Plugin hinzufügen, um die Spring-BOM zu aktivieren.
|
||||
alias(libs.plugins.spring.dependencyManagement)
|
||||
alias(libs.plugins.kotlinJvm)
|
||||
alias(libs.plugins.kotlinSpring)
|
||||
alias(libs.plugins.kotlinSerialization)
|
||||
alias(libs.plugins.ktor)
|
||||
application
|
||||
alias(libs.plugins.spring.dependencyManagement)
|
||||
}
|
||||
|
||||
application {
|
||||
mainClass.set("at.mocode.events.api.ApplicationKt")
|
||||
mainClass.set("at.mocode.events.api.ApplicationKt")
|
||||
}
|
||||
|
||||
dependencies {
|
||||
// KORREKTUR 2: Die Spring-Boot-BOM hier explizit als Plattform deklarieren.
|
||||
api(platform(libs.spring.boot.dependencies))
|
||||
// Bestehende Abhängigkeiten
|
||||
implementation(projects.platform.platformDependencies)
|
||||
implementation(projects.events.eventsDomain)
|
||||
implementation(projects.events.eventsApplication)
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
// Spring dependencies (jetzt mit korrekter Version aus der BOM)
|
||||
implementation(libs.spring.web)
|
||||
implementation(libs.springdoc.openapi.starter.common)
|
||||
// Ktor Server
|
||||
implementation(libs.ktor.server.core)
|
||||
implementation(libs.ktor.server.netty)
|
||||
implementation(libs.ktor.server.contentNegotiation)
|
||||
implementation(libs.ktor.server.serialization.kotlinx.json)
|
||||
implementation(libs.ktor.server.statusPages)
|
||||
implementation(libs.ktor.server.auth)
|
||||
implementation(libs.ktor.server.authJwt)
|
||||
api(platform(libs.spring.boot.dependencies))
|
||||
implementation(projects.platform.platformDependencies)
|
||||
implementation(projects.backend.services.events.eventsDomain)
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
implementation(libs.spring.web)
|
||||
implementation(libs.springdoc.openapi.starter.common)
|
||||
implementation(libs.ktor.server.core)
|
||||
implementation(libs.ktor.server.netty)
|
||||
implementation(libs.ktor.server.contentNegotiation)
|
||||
implementation(libs.ktor.server.serialization.kotlinx.json)
|
||||
implementation(libs.ktor.server.statusPages)
|
||||
implementation(libs.ktor.server.auth)
|
||||
implementation(libs.ktor.server.authJwt)
|
||||
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
// Ktor 3.x Test-Host statt veraltetes tests-Artefakt
|
||||
testImplementation(libs.ktor.server.testHost)
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
testImplementation(libs.ktor.server.testHost)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,15 +1,11 @@
|
|||
@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
|
||||
package at.mocode.events.api.rest
|
||||
|
||||
import at.mocode.events.domain.model.Veranstaltung
|
||||
import at.mocode.core.domain.model.ApiResponse
|
||||
import at.mocode.core.domain.model.SparteE
|
||||
import at.mocode.events.application.usecase.CreateVeranstaltungUseCase
|
||||
import at.mocode.events.application.usecase.DeleteVeranstaltungUseCase
|
||||
import at.mocode.events.application.usecase.GetVeranstaltungUseCase
|
||||
import at.mocode.events.application.usecase.UpdateVeranstaltungUseCase
|
||||
import at.mocode.events.domain.repository.VeranstaltungRepository
|
||||
import at.mocode.core.domain.serialization.UuidSerializer
|
||||
import at.mocode.core.utils.validation.ApiValidationUtils
|
||||
import kotlin.uuid.Uuid
|
||||
import io.ktor.http.*
|
||||
import io.ktor.server.request.*
|
||||
|
|
@ -28,11 +24,6 @@ class VeranstaltungController(
|
|||
private val veranstaltungRepository: VeranstaltungRepository
|
||||
) {
|
||||
|
||||
private val createVeranstaltungUseCase = CreateVeranstaltungUseCase(veranstaltungRepository)
|
||||
private val getVeranstaltungUseCase = GetVeranstaltungUseCase(veranstaltungRepository)
|
||||
private val updateVeranstaltungUseCase = UpdateVeranstaltungUseCase(veranstaltungRepository)
|
||||
private val deleteVeranstaltungUseCase = DeleteVeranstaltungUseCase(veranstaltungRepository)
|
||||
|
||||
/**
|
||||
* Configures the event-related routes.
|
||||
*/
|
||||
|
|
@ -42,31 +33,17 @@ class VeranstaltungController(
|
|||
// GET /api/events - Get all events with optional filtering
|
||||
get {
|
||||
try {
|
||||
// Validate query parameters
|
||||
val validationErrors = ApiValidationUtils.validateQueryParameters(
|
||||
limit = call.request.queryParameters["limit"],
|
||||
offset = call.request.queryParameters["offset"],
|
||||
startDate = call.request.queryParameters["startDate"],
|
||||
endDate = call.request.queryParameters["endDate"],
|
||||
search = call.request.queryParameters["search"]
|
||||
)
|
||||
|
||||
if (!ApiValidationUtils.isValid(validationErrors)) {
|
||||
call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>(ApiValidationUtils.createErrorMessage(validationErrors))
|
||||
)
|
||||
return@get
|
||||
}
|
||||
|
||||
val activeOnly = call.request.queryParameters["activeOnly"]?.toBoolean() ?: true
|
||||
val limit = call.request.queryParameters["limit"]?.toInt() ?: 100
|
||||
val offset = call.request.queryParameters["offset"]?.toInt() ?: 0
|
||||
|
||||
val organizerId = call.request.queryParameters["organizerId"]?.let {
|
||||
ApiValidationUtils.validateUuidString(it) ?: return@get call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("Invalid organizerId format")
|
||||
)
|
||||
try { Uuid.parse(it) } catch (e: Exception) {
|
||||
return@get call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("INVALID_ORGANIZER_ID", "Invalid organizerId format")
|
||||
)
|
||||
}
|
||||
}
|
||||
val searchTerm = call.request.queryParameters["search"]
|
||||
val publicOnly = call.request.queryParameters["publicOnly"]?.toBoolean() ?: false
|
||||
|
|
@ -84,7 +61,7 @@ class VeranstaltungController(
|
|||
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success(events))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to retrieve events: ${e.message}"))
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("INTERNAL_ERROR", "Failed to retrieve events: ${e.message}"))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -92,18 +69,17 @@ class VeranstaltungController(
|
|||
get("/{id}") {
|
||||
try {
|
||||
val eventId = Uuid.parse(call.parameters["id"]!!)
|
||||
val request = GetVeranstaltungUseCase.GetVeranstaltungRequest(eventId)
|
||||
val response = getVeranstaltungUseCase.execute(request)
|
||||
val event = veranstaltungRepository.findById(eventId)
|
||||
|
||||
if (response.success && response.data != null) {
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success((response.data as GetVeranstaltungUseCase.GetVeranstaltungResponse).veranstaltung))
|
||||
if (event != null) {
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success(event))
|
||||
} else {
|
||||
call.respond(HttpStatusCode.NotFound, ApiResponse.error<Any>("Event not found"))
|
||||
call.respond(HttpStatusCode.NotFound, ApiResponse.error<Any>("NOT_FOUND", "Event not found"))
|
||||
}
|
||||
} catch (_: IllegalArgumentException) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid event ID format"))
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("INVALID_ID", "Invalid event ID format"))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to retrieve event: ${e.message}"))
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("INTERNAL_ERROR", "Failed to retrieve event: ${e.message}"))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -120,7 +96,7 @@ class VeranstaltungController(
|
|||
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success(stats))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to retrieve event statistics: ${e.message}"))
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("INTERNAL_ERROR", "Failed to retrieve event statistics: ${e.message}"))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -129,26 +105,12 @@ class VeranstaltungController(
|
|||
try {
|
||||
val createRequest = call.receive<CreateEventRequest>()
|
||||
|
||||
// Validate input using shared validation utilities
|
||||
val validationErrors = ApiValidationUtils.validateEventRequest(
|
||||
name = createRequest.name,
|
||||
ort = createRequest.ort,
|
||||
startDatum = createRequest.startDatum,
|
||||
endDatum = createRequest.endDatum,
|
||||
maxTeilnehmer = createRequest.maxTeilnehmer
|
||||
)
|
||||
|
||||
if (!ApiValidationUtils.isValid(validationErrors)) {
|
||||
call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>(ApiValidationUtils.createErrorMessage(validationErrors))
|
||||
)
|
||||
return@post
|
||||
}
|
||||
|
||||
val useCaseRequest = CreateVeranstaltungUseCase.CreateVeranstaltungRequest(
|
||||
val veranstaltung = Veranstaltung(
|
||||
name = createRequest.name,
|
||||
untertitel = createRequest.untertitel,
|
||||
beschreibung = createRequest.beschreibung,
|
||||
logoUrl = createRequest.logoUrl,
|
||||
sponsoren = createRequest.sponsoren,
|
||||
startDatum = createRequest.startDatum,
|
||||
endDatum = createRequest.endDatum,
|
||||
ort = createRequest.ort,
|
||||
|
|
@ -160,20 +122,16 @@ class VeranstaltungController(
|
|||
anmeldeschluss = createRequest.anmeldeschluss
|
||||
)
|
||||
|
||||
val response = createVeranstaltungUseCase.execute(useCaseRequest)
|
||||
|
||||
if (response.success && response.data != null) {
|
||||
call.respond(HttpStatusCode.Created, ApiResponse.success((response.data as CreateVeranstaltungUseCase.CreateVeranstaltungResponse).veranstaltung))
|
||||
} else {
|
||||
val statusCode = when (response.error?.code) {
|
||||
"VALIDATION_ERROR" -> HttpStatusCode.BadRequest
|
||||
"DOMAIN_VALIDATION_ERROR" -> HttpStatusCode.BadRequest
|
||||
else -> HttpStatusCode.InternalServerError
|
||||
}
|
||||
call.respond(statusCode, ApiResponse.error<Any>(response.error?.message ?: "Failed to create event"))
|
||||
val errors = veranstaltung.validate()
|
||||
if (errors.isNotEmpty()) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("VALIDATION_ERROR", "Validation failed: ${errors.joinToString(", ")}"))
|
||||
return@post
|
||||
}
|
||||
|
||||
val savedEvent = veranstaltungRepository.save(veranstaltung)
|
||||
call.respond(HttpStatusCode.Created, ApiResponse.success(savedEvent))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid request data: ${e.message}"))
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("INVALID_REQUEST", "Invalid request data: ${e.message}"))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -183,27 +141,18 @@ class VeranstaltungController(
|
|||
val eventId = Uuid.parse(call.parameters["id"]!!)
|
||||
val updateRequest = call.receive<UpdateEventRequest>()
|
||||
|
||||
// Validate input using shared validation utilities
|
||||
val validationErrors = ApiValidationUtils.validateEventRequest(
|
||||
name = updateRequest.name,
|
||||
ort = updateRequest.ort,
|
||||
startDatum = updateRequest.startDatum,
|
||||
endDatum = updateRequest.endDatum,
|
||||
maxTeilnehmer = updateRequest.maxTeilnehmer
|
||||
)
|
||||
|
||||
if (!ApiValidationUtils.isValid(validationErrors)) {
|
||||
call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>(ApiValidationUtils.createErrorMessage(validationErrors))
|
||||
)
|
||||
val existingEvent = veranstaltungRepository.findById(eventId)
|
||||
if (existingEvent == null) {
|
||||
call.respond(HttpStatusCode.NotFound, ApiResponse.error<Any>("NOT_FOUND", "Event not found"))
|
||||
return@put
|
||||
}
|
||||
|
||||
val useCaseRequest = UpdateVeranstaltungUseCase.UpdateVeranstaltungRequest(
|
||||
veranstaltungId = eventId,
|
||||
val updatedVeranstaltung = existingEvent.copy(
|
||||
name = updateRequest.name,
|
||||
untertitel = updateRequest.untertitel,
|
||||
beschreibung = updateRequest.beschreibung,
|
||||
logoUrl = updateRequest.logoUrl,
|
||||
sponsoren = updateRequest.sponsoren,
|
||||
startDatum = updateRequest.startDatum,
|
||||
endDatum = updateRequest.endDatum,
|
||||
ort = updateRequest.ort,
|
||||
|
|
@ -213,72 +162,46 @@ class VeranstaltungController(
|
|||
istOeffentlich = updateRequest.istOeffentlich,
|
||||
maxTeilnehmer = updateRequest.maxTeilnehmer,
|
||||
anmeldeschluss = updateRequest.anmeldeschluss
|
||||
)
|
||||
).withUpdatedTimestamp()
|
||||
|
||||
val response = updateVeranstaltungUseCase.execute(useCaseRequest)
|
||||
|
||||
if (response.success && response.data != null) {
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success((response.data as UpdateVeranstaltungUseCase.UpdateVeranstaltungResponse).veranstaltung))
|
||||
} else {
|
||||
val statusCode = when (response.error?.code) {
|
||||
"NOT_FOUND" -> HttpStatusCode.NotFound
|
||||
"VALIDATION_ERROR" -> HttpStatusCode.BadRequest
|
||||
"DOMAIN_VALIDATION_ERROR" -> HttpStatusCode.BadRequest
|
||||
else -> HttpStatusCode.InternalServerError
|
||||
}
|
||||
call.respond(statusCode, ApiResponse.error<Any>(response.error?.message ?: "Failed to update event"))
|
||||
val errors = updatedVeranstaltung.validate()
|
||||
if (errors.isNotEmpty()) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("VALIDATION_ERROR", "Validation failed: ${errors.joinToString(", ")}"))
|
||||
return@put
|
||||
}
|
||||
|
||||
val savedEvent = veranstaltungRepository.save(updatedVeranstaltung)
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success(savedEvent))
|
||||
} catch (_: IllegalArgumentException) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid event ID format"))
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("INVALID_ID", "Invalid event ID format"))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid request data: ${e.message}"))
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("INVALID_REQUEST", "Invalid request data: ${e.message}"))
|
||||
}
|
||||
}
|
||||
|
||||
// DELETE /api/events/{id} - Delete event
|
||||
delete("/{id}") {
|
||||
try {
|
||||
val eventId = ApiValidationUtils.validateUuidString(call.parameters["id"])
|
||||
?: return@delete call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("Invalid event ID format")
|
||||
)
|
||||
|
||||
// Validate force parameter if provided
|
||||
val forceParam = call.request.queryParameters["force"]
|
||||
val forceDelete = if (forceParam != null) {
|
||||
try {
|
||||
forceParam.toBoolean()
|
||||
} catch (_: Exception) {
|
||||
return@delete call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("Invalid force parameter. Must be true or false")
|
||||
)
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
val useCaseRequest = DeleteVeranstaltungUseCase.DeleteVeranstaltungRequest(
|
||||
veranstaltungId = eventId,
|
||||
forceDelete = forceDelete
|
||||
val eventIdString = call.parameters["id"] ?: return@delete call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("MISSING_ID", "Event ID is required")
|
||||
)
|
||||
|
||||
val response = deleteVeranstaltungUseCase.execute(useCaseRequest)
|
||||
|
||||
if (response.success) {
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success(response.data))
|
||||
} else {
|
||||
val statusCode = when (response.error?.code) {
|
||||
"NOT_FOUND" -> HttpStatusCode.NotFound
|
||||
"CANNOT_DELETE_ACTIVE_EVENT" -> HttpStatusCode.Conflict
|
||||
else -> HttpStatusCode.InternalServerError
|
||||
}
|
||||
call.respond(statusCode, ApiResponse.error<Any>(response.error?.message ?: "Failed to delete event"))
|
||||
val eventId = try { Uuid.parse(eventIdString) } catch (e: Exception) {
|
||||
return@delete call.respond(
|
||||
HttpStatusCode.BadRequest,
|
||||
ApiResponse.error<Any>("INVALID_ID", "Invalid event ID format")
|
||||
)
|
||||
}
|
||||
|
||||
val success = veranstaltungRepository.delete(eventId)
|
||||
if (success) {
|
||||
call.respond(HttpStatusCode.OK, ApiResponse.success("Event deleted successfully"))
|
||||
} else {
|
||||
call.respond(HttpStatusCode.NotFound, ApiResponse.error<Any>("NOT_FOUND", "Event not found"))
|
||||
}
|
||||
} catch (_: IllegalArgumentException) {
|
||||
call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid event ID format"))
|
||||
} catch (e: Exception) {
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to delete event: ${e.message}"))
|
||||
call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("INTERNAL_ERROR", "Failed to delete event: ${e.message}"))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -290,7 +213,10 @@ class VeranstaltungController(
|
|||
@Serializable
|
||||
data class CreateEventRequest(
|
||||
val name: String,
|
||||
val untertitel: String? = null,
|
||||
val beschreibung: String? = null,
|
||||
val logoUrl: String? = null,
|
||||
val sponsoren: String? = null,
|
||||
val startDatum: LocalDate,
|
||||
val endDatum: LocalDate,
|
||||
val ort: String,
|
||||
|
|
@ -309,7 +235,10 @@ class VeranstaltungController(
|
|||
@Serializable
|
||||
data class UpdateEventRequest(
|
||||
val name: String,
|
||||
val untertitel: String? = null,
|
||||
val beschreibung: String? = null,
|
||||
val logoUrl: String? = null,
|
||||
val sponsoren: String? = null,
|
||||
val startDatum: LocalDate,
|
||||
val endDatum: LocalDate,
|
||||
val ort: String,
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
plugins {
|
||||
// KORREKTUR: Von 'kotlin("jvm")' zu Multiplattform wechseln.
|
||||
alias(libs.plugins.kotlin.multiplatform)
|
||||
alias(libs.plugins.kotlin.serialization)
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
alias(libs.plugins.kotlinSerialization)
|
||||
}
|
||||
|
||||
kotlin {
|
||||
|
|
@ -25,6 +24,11 @@ kotlin {
|
|||
val commonTest by getting {
|
||||
dependencies {
|
||||
implementation(kotlin("test"))
|
||||
}
|
||||
}
|
||||
|
||||
val jvmTest by getting {
|
||||
dependencies {
|
||||
implementation(projects.platform.platformTesting)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
plugins {
|
||||
kotlin("jvm")
|
||||
alias(libs.plugins.kotlinJvm)
|
||||
alias(libs.plugins.kotlinSerialization)
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
implementation(libs.kotlinx.datetime)
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,8 +4,9 @@ package at.mocode.events.domain.model
|
|||
|
||||
import at.mocode.core.domain.model.AusschreibungsStatusE
|
||||
import at.mocode.core.domain.model.SparteE
|
||||
import at.mocode.core.domain.serialization.KotlinxInstantSerializer
|
||||
import at.mocode.core.domain.serialization.InstantSerializer
|
||||
import at.mocode.core.domain.serialization.UuidSerializer
|
||||
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlin.time.Clock
|
||||
|
|
@ -44,7 +45,7 @@ import kotlin.uuid.Uuid
|
|||
* @property updatedAt Letzter Änderungszeitpunkt.
|
||||
*/
|
||||
@Serializable
|
||||
data class DomAusschreibung(
|
||||
data class Ausschreibung(
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
val ausschreibungsId: Uuid = Uuid.random(),
|
||||
|
||||
|
|
@ -88,9 +89,9 @@ data class DomAusschreibung(
|
|||
var genehmigungsNummer: String? = null,
|
||||
|
||||
// Audit
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
val createdAt: Instant = Clock.System.now(),
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
var updatedAt: Instant = Clock.System.now()
|
||||
) {
|
||||
/**
|
||||
|
|
@ -150,5 +151,5 @@ data class DomAusschreibung(
|
|||
/**
|
||||
* Erstellt eine Kopie mit aktualisiertem Zeitstempel.
|
||||
*/
|
||||
fun withUpdatedTimestamp(): DomAusschreibung = this.copy(updatedAt = Clock.System.now())
|
||||
fun withUpdatedTimestamp(): Ausschreibung = this.copy(updatedAt = Clock.System.now())
|
||||
}
|
||||
|
|
@ -8,7 +8,7 @@ import at.mocode.core.domain.model.TurnierkategorieE
|
|||
import at.mocode.core.domain.model.TurnierStatusE
|
||||
import at.mocode.events.domain.validation.TurnierBewerbDescriptor
|
||||
import at.mocode.events.domain.validation.TurnierkategoriePolicy
|
||||
import at.mocode.core.domain.serialization.KotlinxInstantSerializer
|
||||
import at.mocode.core.domain.serialization.InstantSerializer
|
||||
import at.mocode.core.domain.serialization.UuidSerializer
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.serialization.Serializable
|
||||
|
|
@ -39,7 +39,7 @@ import kotlin.uuid.Uuid
|
|||
* @property updatedAt Letzter Änderungszeitpunkt.
|
||||
*/
|
||||
@Serializable
|
||||
data class DomTurnier(
|
||||
data class Turnier(
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
val turnierId: Uuid = Uuid.random(),
|
||||
|
||||
|
|
@ -72,13 +72,13 @@ data class DomTurnier(
|
|||
var bemerkungen: String? = null,
|
||||
|
||||
// Audit
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
val createdAt: Instant = Clock.System.now(),
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
var updatedAt: Instant = Clock.System.now()
|
||||
) {
|
||||
/**
|
||||
* Prüft ob das Turnier Pflicht-Funktionäre zugewiesen hat.
|
||||
* Prüft, ob das Turnier Pflicht-Funktionäre zugewiesen hat.
|
||||
* Gibt Warnungen zurück – keine harten Fehler (Warn-Logik statt Exception, ADR-0007).
|
||||
*/
|
||||
fun validateFunktionaerBesetzung(): List<String> {
|
||||
|
|
@ -115,13 +115,13 @@ data class DomTurnier(
|
|||
/**
|
||||
* Erstellt eine Kopie mit aktualisiertem Zeitstempel.
|
||||
*/
|
||||
fun withUpdatedTimestamp(): DomTurnier = this.copy(updatedAt = Clock.System.now())
|
||||
fun withUpdatedTimestamp(): Turnier = this.copy(updatedAt = Clock.System.now())
|
||||
|
||||
/**
|
||||
* Validiert die im Turnier geplanten Bewerbe gegen die Limits der Turnierkategorie.
|
||||
*
|
||||
* Hinweis: Die konkreten Regeln stammen aus der ÖTO-Spezifikation und werden vom 📜 Rulebook Expert (A-5)
|
||||
* bereitgestellt. Diese Methode delegiert daher an eine Policy-Schnittstelle, um Kopplung zu vermeiden und
|
||||
* bereitgestellt. Diese Methode delegiert sich daher an eine Policy-Schnittstelle, um Kopplung zu vermeiden und
|
||||
* die Regeln austauschbar zu halten.
|
||||
*
|
||||
* Rückgabe: Liste von Meldungen (Fehler/Warnungen) – Formulierung/Schweregrad ist Teil der Policy.
|
||||
|
|
@ -2,15 +2,15 @@
|
|||
package at.mocode.events.domain.model
|
||||
|
||||
import at.mocode.core.domain.model.SparteE
|
||||
import at.mocode.core.domain.serialization.KotlinxInstantSerializer
|
||||
import at.mocode.core.domain.serialization.KotlinLocalDateSerializer
|
||||
import at.mocode.core.domain.serialization.InstantSerializer
|
||||
import at.mocode.core.domain.serialization.LocalDateSerializer
|
||||
import at.mocode.core.domain.serialization.UuidSerializer
|
||||
import kotlin.uuid.Uuid
|
||||
import kotlinx.datetime.Clock
|
||||
import kotlinx.datetime.Instant
|
||||
|
||||
import kotlinx.datetime.LocalDate
|
||||
import kotlinx.datetime.TimeZone
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlin.time.Clock
|
||||
import kotlin.time.Instant
|
||||
|
||||
/**
|
||||
* Domain model representing an event/competition in the event management system.
|
||||
|
|
@ -35,40 +35,40 @@ import kotlinx.serialization.Serializable
|
|||
*/
|
||||
@Serializable
|
||||
data class Veranstaltung(
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
val veranstaltungId: Uuid = Uuid.random(),
|
||||
|
||||
// Basic Information
|
||||
var name: String,
|
||||
var untertitel: String? = null,
|
||||
var beschreibung: String? = null,
|
||||
var logoUrl: String? = null,
|
||||
var sponsoren: String? = null, // JSON string or comma-separated for now
|
||||
var name: String,
|
||||
var untertitel: String? = null,
|
||||
var beschreibung: String? = null,
|
||||
var logoUrl: String? = null,
|
||||
var sponsoren: String? = null, // JSON string or comma-separated for now
|
||||
|
||||
// Dates
|
||||
@Serializable(with = KotlinLocalDateSerializer::class)
|
||||
@Serializable(with = LocalDateSerializer::class)
|
||||
var startDatum: LocalDate,
|
||||
@Serializable(with = KotlinLocalDateSerializer::class)
|
||||
@Serializable(with = LocalDateSerializer::class)
|
||||
var endDatum: LocalDate,
|
||||
|
||||
// Location and Organization
|
||||
var ort: String,
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
var ort: String,
|
||||
@Serializable(with = UuidSerializer::class)
|
||||
var veranstalterVereinId: Uuid,
|
||||
|
||||
// Event Details
|
||||
var sparten: List<SparteE> = emptyList(),
|
||||
var istAktiv: Boolean = true,
|
||||
var istOeffentlich: Boolean = true,
|
||||
var maxTeilnehmer: Int? = null,
|
||||
var sparten: List<SparteE> = emptyList(),
|
||||
var istAktiv: Boolean = true,
|
||||
var istOeffentlich: Boolean = true,
|
||||
var maxTeilnehmer: Int? = null,
|
||||
|
||||
@Serializable(with = KotlinLocalDateSerializer::class)
|
||||
@Serializable(with = LocalDateSerializer::class)
|
||||
var anmeldeschluss: LocalDate? = null,
|
||||
|
||||
// Audit Fields
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
val createdAt: Instant = Clock.System.now(),
|
||||
@Serializable(with = KotlinxInstantSerializer::class)
|
||||
@Serializable(with = InstantSerializer::class)
|
||||
var updatedAt: Instant = Clock.System.now()
|
||||
) {
|
||||
/**
|
||||
|
|
@ -127,7 +127,7 @@ data class Veranstaltung(
|
|||
}
|
||||
|
||||
/**
|
||||
* Creates a copy of this event with updated timestamp.
|
||||
* Creates a copy of this event with an updated timestamp.
|
||||
*/
|
||||
fun withUpdatedTimestamp(): Veranstaltung {
|
||||
return this.copy(updatedAt = Clock.System.now())
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ data class TurnierBewerbDescriptor(
|
|||
|
||||
/**
|
||||
* Policy-Schnittstelle für die Validierung der Turnierkategorie-Limits (ÖTO-Regelwerk).
|
||||
* Implementierung wird durch den 📜 Rulebook Expert (A-5) spezifiziert.
|
||||
* Die Implementierung wird durch den 📜 Rulebook Expert (A-5) spezifiziert.
|
||||
*/
|
||||
fun interface TurnierkategoriePolicy {
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -4,12 +4,13 @@ import at.mocode.core.domain.model.SparteE
|
|||
import at.mocode.core.domain.model.TurnierkategorieE
|
||||
import at.mocode.events.domain.validation.TurnierBewerbDescriptor
|
||||
import at.mocode.events.domain.validation.TurnierkategoriePolicy
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.uuid.Uuid
|
||||
import kotlinx.datetime.LocalDate
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import org.junit.jupiter.api.Test
|
||||
import kotlin.uuid.ExperimentalUuidApi
|
||||
|
||||
class DomTurnierKategorieValidationTest {
|
||||
class TurnierKategorieValidationTest {
|
||||
|
||||
private val fakePolicy = TurnierkategoriePolicy { kategorie, bewerbe ->
|
||||
val msgs = mutableListOf<String>()
|
||||
|
|
@ -29,11 +30,13 @@ class DomTurnierKategorieValidationTest {
|
|||
msgs
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalUuidApi::class)
|
||||
@Test
|
||||
fun `C Turnier verbietet 135cm Springen`() {
|
||||
val turnier = DomTurnier(
|
||||
val turnier = Turnier(
|
||||
veranstaltungId = Uuid.random(),
|
||||
name = "CSN-C Samstag",
|
||||
turnierNummer = "12345",
|
||||
sparte = SparteE.SPRINGEN,
|
||||
kategorie = TurnierkategorieE.C,
|
||||
datum = LocalDate(2026, 6, 1)
|
||||
|
|
@ -48,11 +51,13 @@ class DomTurnierKategorieValidationTest {
|
|||
assertEquals(1, msgs.size, "Erwartet genau eine Limitverletzung (135cm auf C-Turnier)")
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalUuidApi::class)
|
||||
@Test
|
||||
fun `C-NEU Turnier verbietet 120cm`() {
|
||||
val turnier = DomTurnier(
|
||||
val turnier = Turnier(
|
||||
veranstaltungId = Uuid.random(),
|
||||
name = "CSN-C-NEU",
|
||||
turnierNummer = "12345",
|
||||
sparte = SparteE.SPRINGEN,
|
||||
kategorie = TurnierkategorieE.C_NEU,
|
||||
datum = LocalDate(2026, 6, 1)
|
||||
|
|
|
|||
|
|
@ -2,8 +2,9 @@ package at.mocode.events.domain.validation
|
|||
|
||||
import at.mocode.core.domain.model.SparteE
|
||||
import at.mocode.core.domain.model.TurnierkategorieE
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import org.junit.jupiter.api.Test
|
||||
|
||||
|
||||
class OeToTurnierkategoriePolicyTest {
|
||||
|
||||
|
|
|
|||
|
|
@ -1,24 +1,29 @@
|
|||
plugins {
|
||||
alias(libs.plugins.kotlin.jvm)
|
||||
alias(libs.plugins.kotlin.spring)
|
||||
alias(libs.plugins.kotlin.serialization)
|
||||
alias(libs.plugins.ktor)
|
||||
application
|
||||
alias(libs.plugins.kotlinJvm)
|
||||
alias(libs.plugins.kotlinSpring)
|
||||
alias(libs.plugins.kotlinSerialization)
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(projects.platform.platformDependencies)
|
||||
implementation(platform(projects.platform.platformBom))
|
||||
implementation(projects.platform.platformDependencies)
|
||||
implementation(projects.backend.services.events.eventsDomain)
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
implementation(projects.backend.infrastructure.cache.cacheApi)
|
||||
implementation(projects.backend.infrastructure.eventStore.eventStoreApi)
|
||||
implementation(projects.backend.infrastructure.messaging.messagingClient)
|
||||
implementation(projects.backend.infrastructure.persistence)
|
||||
|
||||
implementation(projects.events.eventsDomain)
|
||||
implementation(projects.events.eventsApplication)
|
||||
implementation(projects.core.coreDomain)
|
||||
implementation(projects.core.coreUtils)
|
||||
implementation(projects.infrastructure.cache.cacheApi)
|
||||
implementation(projects.infrastructure.eventStore.eventStoreApi)
|
||||
implementation(projects.infrastructure.messaging.messagingClient)
|
||||
implementation(libs.exposed.core)
|
||||
implementation(libs.exposed.dao)
|
||||
implementation(libs.exposed.jdbc)
|
||||
implementation(libs.exposed.kotlin.datetime)
|
||||
implementation(libs.exposed.java.time)
|
||||
implementation(libs.exposed.json)
|
||||
|
||||
implementation(libs.spring.boot.starter.data.jpa)
|
||||
implementation(libs.postgresql.driver)
|
||||
implementation(libs.spring.boot.starter.data.jpa)
|
||||
implementation(libs.postgresql.driver)
|
||||
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
testImplementation(projects.platform.platformTesting)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,10 +1,9 @@
|
|||
package at.mocode.events.infrastructure.persistence
|
||||
|
||||
import at.mocode.core.domain.model.SparteE
|
||||
import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
|
||||
import org.jetbrains.exposed.v1.core.kotlin.datetime.date
|
||||
import org.jetbrains.exposed.v1.core.kotlin.datetime.timestamp
|
||||
import org.jetbrains.exposed.v1.core.javaUUID
|
||||
import org.jetbrains.exposed.v1.core.Table
|
||||
import org.jetbrains.exposed.v1.core.java.javaUUID
|
||||
import org.jetbrains.exposed.v1.datetime.timestamp
|
||||
import org.jetbrains.exposed.v1.datetime.date
|
||||
|
||||
/**
|
||||
* Database table definition for events (Veranstaltung) in the event-management context.
|
||||
|
|
@ -12,7 +11,10 @@ import org.jetbrains.exposed.v1.core.javaUUID
|
|||
* This table stores all event information including dates, location,
|
||||
* organization details, and administrative information.
|
||||
*/
|
||||
object VeranstaltungTable : UUIDTable("veranstaltungen") {
|
||||
object VeranstaltungTable : Table("veranstaltungen") {
|
||||
|
||||
val id = javaUUID("id").autoGenerate()
|
||||
override val primaryKey = PrimaryKey(id)
|
||||
|
||||
// Basic Information
|
||||
val name = varchar("name", 255)
|
||||
|
|
|
|||
|
|
@ -1,21 +1,15 @@
|
|||
package at.mocode.events.service.config
|
||||
|
||||
import at.mocode.core.utils.database.DatabaseConfig
|
||||
import at.mocode.core.utils.database.DatabaseFactory
|
||||
import at.mocode.events.infrastructure.persistence.VeranstaltungTable
|
||||
import org.springframework.context.annotation.Configuration
|
||||
import org.springframework.context.annotation.Profile
|
||||
import jakarta.annotation.PostConstruct
|
||||
import jakarta.annotation.PreDestroy
|
||||
import org.slf4j.LoggerFactory
|
||||
import org.jetbrains.exposed.sql.SchemaUtils
|
||||
import org.jetbrains.exposed.sql.transactions.transaction
|
||||
|
||||
/**
|
||||
* Database configuration for the Events Service.
|
||||
* Datenbank-Konfiguration für den Events Service.
|
||||
*
|
||||
* This configuration ensures that Database.connect() is called properly
|
||||
* before any Exposed operations are performed.
|
||||
* Initialisiert das Exposed-Schema für Veranstaltungen und Turniere.
|
||||
* Die DB-Verbindung selbst wird durch den zentralen DataSource-Bean initialisiert.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("!test")
|
||||
|
|
@ -25,35 +19,13 @@ class EventsDatabaseConfiguration {
|
|||
|
||||
@PostConstruct
|
||||
fun initializeDatabase() {
|
||||
log.info("Initializing database schema for Events Service...")
|
||||
|
||||
try {
|
||||
// Database connection is already initialized by the gateway
|
||||
// Only initialize the schema for this service
|
||||
transaction {
|
||||
SchemaUtils.create(VeranstaltungTable)
|
||||
log.info("Events database schema initialized successfully")
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
log.error("Failed to initialize database schema", e)
|
||||
throw e
|
||||
}
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
fun closeDatabase() {
|
||||
log.info("Closing database connection for Events Service...")
|
||||
try {
|
||||
DatabaseFactory.close()
|
||||
log.info("Database connection closed successfully")
|
||||
} catch (e: Exception) {
|
||||
log.error("Error closing database connection", e)
|
||||
}
|
||||
// Flyway übernimmt ab jetzt die Schema-Erstellung pro Tenant.
|
||||
log.info("Überspringe Exposed Schema-Initialisierung – Flyway migriert pro Tenant-Schema.")
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test-specific database configuration.
|
||||
* Test-spezifische Datenbank-Konfiguration.
|
||||
*/
|
||||
@Configuration
|
||||
@Profile("test")
|
||||
|
|
@ -63,42 +35,6 @@ class EventsTestDatabaseConfiguration {
|
|||
|
||||
@PostConstruct
|
||||
fun initializeTestDatabase() {
|
||||
log.info("Initializing test database connection for Events Service...")
|
||||
|
||||
try {
|
||||
// Use H2 in-memory database for tests
|
||||
val testConfig = DatabaseConfig(
|
||||
jdbcUrl = "jdbc:h2:mem:events_test;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
|
||||
username = "sa",
|
||||
password = "",
|
||||
driverClassName = "org.h2.Driver",
|
||||
maxPoolSize = 5,
|
||||
minPoolSize = 1,
|
||||
autoMigrate = true
|
||||
)
|
||||
|
||||
DatabaseFactory.init(testConfig)
|
||||
log.info("Test database connection initialized successfully")
|
||||
|
||||
// Initialize database schema for tests
|
||||
transaction {
|
||||
SchemaUtils.create(VeranstaltungTable)
|
||||
log.info("Test events database schema initialized successfully")
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
log.error("Failed to initialize test database connection", e)
|
||||
throw e
|
||||
}
|
||||
}
|
||||
|
||||
@PreDestroy
|
||||
fun closeTestDatabase() {
|
||||
log.info("Closing test database connection for Events Service...")
|
||||
try {
|
||||
DatabaseFactory.close()
|
||||
log.info("Test database connection closed successfully")
|
||||
} catch (e: Exception) {
|
||||
log.error("Error closing test database connection", e)
|
||||
}
|
||||
log.info("Initialisiere Test-Datenbank-Schema für den Events Service...")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -100,16 +100,57 @@ val myNewProperty by extra("Initialwert")
|
|||
val myExtraProperty: String by extra
|
||||
```
|
||||
|
||||
### Kotlin DSL Plugin (`kotlin-dsl`)
|
||||
Dieses Plugin ist essenziell für die Entwicklung von Build-Logik in Kotlin (z.B. in `buildSrc` oder für Convention Plugins). Es wendet automatisch das Kotlin-Plugin an und fügt notwendige Abhängigkeiten wie `kotlin-stdlib` und `gradleKotlinDsl()` hinzu.
|
||||
## Best Practices im Projekt
|
||||
|
||||
### Plugin-Management
|
||||
Im Projekt wird ein zentraler **Version Catalog** (`gradle/libs.versions.toml`) verwendet. Plugins sollten **immer** über Aliase referenziert werden.
|
||||
|
||||
**Korrekt:**
|
||||
```kotlin
|
||||
// buildSrc/build.gradle.kts
|
||||
plugins {
|
||||
`kotlin-dsl`
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
alias(libs.plugins.kotlinJvm)
|
||||
alias(libs.plugins.spring.boot)
|
||||
}
|
||||
```
|
||||
|
||||
**Falsch:**
|
||||
```kotlin
|
||||
plugins {
|
||||
kotlin("jvm") // Veraltet/Inkonsistent
|
||||
id("org.springframework.boot") version "3.4.0" // Version gehört in den Catalog
|
||||
}
|
||||
```
|
||||
|
||||
### Projekt-Referenzen (Accessors)
|
||||
Aufgrund der tiefen Modulstruktur (`backend/services/...`) müssen Projekt-Referenzen den vollen Pfad abbilden, um typsicher zu sein.
|
||||
|
||||
**Korrekt:**
|
||||
```kotlin
|
||||
dependencies {
|
||||
implementation(projects.backend.services.events.eventsDomain)
|
||||
}
|
||||
```
|
||||
|
||||
**Falsch:**
|
||||
```kotlin
|
||||
dependencies {
|
||||
implementation(projects.events.eventsDomain) // Schlägt fehl, wenn nicht direkt unter Root
|
||||
}
|
||||
```
|
||||
|
||||
### Spring Boot vs. Library
|
||||
* **Services** (ausführbar) nutzen `alias(libs.plugins.spring.boot)` und den `springBoot { mainClass = ... }` Block.
|
||||
* **Libraries/Domains** nutzen nur `alias(libs.plugins.kotlinJvm)` (oder Multiplatform) und definieren keine Main-Class.
|
||||
|
||||
### Kotlin Multiplatform (KMP)
|
||||
Für Module, die sowohl im Backend als auch im Frontend (Compose) genutzt werden (z.B. `api`, `common`), wird das KMP-Plugin verwendet:
|
||||
```kotlin
|
||||
plugins {
|
||||
alias(libs.plugins.kotlinMultiplatform)
|
||||
}
|
||||
|
||||
kotlin {
|
||||
jvm()
|
||||
js(IR) { browser() }
|
||||
}
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1092,3 +1092,259 @@ Stelle sicher, dass nach diesen massiven Änderungen im Domain-Modell das Projek
|
|||
|
||||
Bitte meldet euch mit einem Summary zurück, sobald Phase 1 & 2 (Clean-Up & Domain-Modell) erfolgreich abgeschlossen und kompiliert sind!
|
||||
```
|
||||
|
||||
---
|
||||
Junie
|
||||
---
|
||||
|
||||
### Summary
|
||||
- Phase 1 (Domain Clean-Up) und Phase 2 (Modell-Erweiterungen) erfolgreich abgeschlossen. Alle betroffenen Module kompilieren fehlerfrei.
|
||||
|
||||
### Changes
|
||||
- **Phase 1 – Umbenennung (7 Klassen):** `DomBewerb`→`Bewerb`, `DomAbteilung`→`Abteilung`, `DomNennung`→`Nennung`, `DomNennungsTransfer`→`NennungsTransfer` (entries-domain); `DomTurnier`→`Turnier`, `DomAusschreibung`→`Ausschreibung` (events-domain); `DomVeranstaltung.kt` (ungenutztes Duplikat) gelöscht – alle Referenzen systemweit aktualisiert.
|
||||
- **Phase 2 – Enums:** `AbteilungsTeilungsTypE` um `MANUELL` erweitert; neues Enum `BeginnZeitTypE` (`FIX`, `ANSCHLIESSEND`) in `core-domain/Enums.kt` angelegt.
|
||||
- **Phase 2 – Neue Modelle:** `RichterEinsatz` (Value Object, entries-domain), `Austragungsplatz` und `TurnierArtikel` (events-domain) neu erstellt.
|
||||
- **Phase 2 – Bewerb erweitert:** 16 neue Felder in `Bewerb` eingefügt (Text & Details, Ort & Funktionäre, Zeitplan, Finanzen) inkl. korrekter Imports für `BeginnZeitTypE`, `LocalDate`, `LocalTime`.
|
||||
- **Architektur-Doku:** ADR-0023 (Naming Convention, kein `Dom`-Präfix) angelegt; Ubiquitous Language um `Austragungsplatz`, `Vorbereitungsplatz`, `RichterEinsatz`, `TurnierArtikel` ergänzt.
|
||||
|
||||
### Verification
|
||||
- `entries-domain:compileKotlinJvm`, `entries-service:compileKotlin` und `core-domain:compileCommonMainKotlinMetadata` – alle **BUILD SUCCESSFUL**.
|
||||
|
||||
### Notes
|
||||
- `events-domain` ist nicht im Gradle-Build registriert (kein Gradle-Subprojekt) – Kompilierung der neuen events-domain Klassen (`Austragungsplatz`, `TurnierArtikel`, `Turnier`, `Ausschreibung`) konnte nicht direkt verifiziert werden; sie werden beim nächsten vollständigen Build geprüft.
|
||||
- Datenbank-Migrationen (Flyway) und Repository-Mappings für die neuen `Bewerb`-Felder folgen in Phase 3.
|
||||
|
||||
---
|
||||
Gemini
|
||||
---
|
||||
|
||||
🏗️ [Lead Architect]
|
||||
|
||||
Hervorragende Arbeit! Dass Phase 1 und Phase 2 so reibungslos durchgelaufen sind und die Build-Pipeline (bis auf das noch nicht verknüpfte events-domain Modul) grün ist, zeigt, dass wir auf dem absolut richtigen Weg sind. Die Namensgebung ist jetzt sauber (Clean Architecture) und das Bewerb-Modell spiegelt exakt die Realität einer Meldestelle wider.
|
||||
|
||||
Wir können nun direkt mit Phase 3 (Persistenz & Datenbank) weitermachen. Hier sorgen wir dafür, dass die 16 neuen Felder aus dem Bewerb sowie die neuen Modelle in der Datenbank gespeichert und vom Repository korrekt geladen werden.
|
||||
|
||||
Hier ist der fertige Prompt für den nächsten Schritt. Sie können ihn wieder 1:1 kopieren und ausführen lassen:
|
||||
|
||||
```markdown
|
||||
# 🤖 Project Agents & Protocol: Phase 3 – Persistenz & Datenbank (Infrastructure)
|
||||
|
||||
🏗️ **@Lead Architect** & 👷 **@Backend Developer**
|
||||
|
||||
Bitte führt gemeinsam die Phase 3 unseres Architektur-Updates durch. Nachdem in Phase 1 & 2 das Domain-Modell erfolgreich bereinigt und erweitert wurde (z.B. 16 neue Felder im `Bewerb`), müssen diese Änderungen nun in der Datenbank (Flyway) und im Persistenz-Layer (Repositories/Tables) abgebildet werden.
|
||||
|
||||
**Kontext:**
|
||||
Wir nutzen für die Datenbank-Anbindung Kotlin (vermutlich JetBrains Exposed oder Spring Data/JDBC) und Flyway für die Migrationen. Das Ziel ist es, dass ein neu konfigurierter Bewerb inkl. Zeitplan, Finanzen und Richter-Einsätzen fehlerfrei in der Tenant-Datenbank gespeichert und geladen werden kann.
|
||||
|
||||
## 👷 Aufgaben für [Backend Developer]
|
||||
|
||||
Bitte führe die folgenden Anpassungen im Infrastruktur-Layer durch:
|
||||
|
||||
**1. Tabellen-Definitionen anpassen (`.../infrastructure/.../Table.kt`):**
|
||||
* **BewerbTable:** Füge die neuen Spalten hinzu:
|
||||
* `beschreibung` (varchar/text, nullable)
|
||||
* `aufgabe`, `aufgaben_nummer`, `para_grade` (varchar, nullable)
|
||||
* `austragungsplatz_id` (uuid, nullable)
|
||||
* `geplantes_datum` (date, nullable)
|
||||
* `beginn_zeit_typ` (varchar, nullable)
|
||||
* `beginn_zeit` (time, nullable)
|
||||
* `reitdauer_minuten`, `umbau_minuten`, `besichtigung_minuten` (integer, nullable)
|
||||
* `stechen_geplant` (boolean, default false)
|
||||
* `startgeld_cent` (bigint/long, nullable)
|
||||
* `geldpreis_ausbezahlt` (boolean, default false)
|
||||
* **Neue Tabellen (Optional, je nach Kontext-Grenzen):**
|
||||
* Lege eine `AustragungsplatzTable` an (id, name, typ, sparte).
|
||||
* Lege eine `TurnierArtikelTable` an (id, name, preis_cent, typ).
|
||||
* Lege eine `BewerbRichterEinsatzTable` an (bewerb_id, funktionaer_id, position) um die 1:N Beziehung des `RichterEinsatz` abzubilden (alternativ als JSONB-Spalte in `BewerbTable`, falls das im Projekt der Standard für Value-Objects ist).
|
||||
|
||||
**2. Repository-Mapping aktualisieren (`BewerbRepositoryImpl.kt` o.ä.):**
|
||||
* Aktualisiere die `Insert`- und `Update`-Statements, um die neuen Felder des `Bewerb`-Objekts in die Datenbank zu schreiben.
|
||||
* Passe die Mapper-Funktion (z.B. `rowToBewerb`) an, damit beim Auslesen der Datenbank alle neuen Felder (Zeitplan, Finanzen, Text) korrekt in die Domain-Entität `Bewerb` gemappt werden.
|
||||
* Sorge dafür, dass die `richterEinsaetze` beim Laden eines Bewerbs mitgeladen und beim Speichern persistiert werden.
|
||||
|
||||
**3. Flyway-Migration erstellen (`src/main/resources/db/tenant/`):**
|
||||
* Erstelle die nächste logische Migrationsdatei (z.B. `V5__add_bewerb_details_and_infrastructure.sql`).
|
||||
* Schreibe die `ALTER TABLE bewerbe ADD COLUMN ...` Statements für alle neuen Bewerbs-Felder.
|
||||
* Schreibe die `CREATE TABLE` Statements für `austragungsplaetze`, `turnier_artikel` und `bewerb_richter_einsaetze` (inkl. Foreign Keys, falls relational verknüpft).
|
||||
|
||||
**4. Kompilieren & Checken:**
|
||||
* Führe einen vollständigen Build (`./gradlew build` oder ähnlich) aus, um sicherzustellen, dass die Repositories fehlerfrei kompilieren.
|
||||
|
||||
Bitte meldet euch mit einem Summary zurück, sobald die Repositories, Tables und die Flyway-Migration erfolgreich angepasst und kompiliert sind!
|
||||
```
|
||||
|
||||
---
|
||||
Junie
|
||||
---
|
||||
|
||||
### Summary
|
||||
- 👷 [Backend Developer] Phase 3 (Persistenz & Datenbank) erfolgreich abgeschlossen – alle Tests grün, BUILD SUCCESSFUL.
|
||||
|
||||
### Changes
|
||||
- **Flyway V5** (`V5__add_bewerb_details_and_infrastructure.sql`): 14 neue Spalten in `bewerbe` (Text, Zeitplan, Finanzen), `abteilungen`-CHECK um `MANUELL` erweitert, neue Tabellen `austragungsplaetze`, `bewerb_richter_einsaetze`, `turnier_artikel` mit Indizes und Foreign Keys. PostgreSQL-kompatible `DO $$`-Blöcke für idempotente Constraints.
|
||||
- **`BewerbTable.kt`**: Exposed-Table-Definition mit allen 14 neuen Spalten (`date`, `time`, `bool`, `long`, `text`, `varchar`) inkl. `kotlinx-datetime`-kompatibler Typen via `exposed-kotlin-datetime`.
|
||||
- **`BewerbRichterEinsatzTable.kt`**: Neue Exposed-Table für die 1:N-Beziehung `bewerb_richter_einsaetze` mit FK auf `BewerbTable`.
|
||||
- **`BewerbRepository.kt` + `BewerbRepositoryImpl.kt`**: Lokale `Bewerb`-Datenklasse mit allen neuen Feldern; vollständiges CRUD-Repository inkl. `persistRichterEinsaetze` (delete+insert) und `loadRichterEinsaetze` beim Lesen.
|
||||
|
||||
### Verification
|
||||
- `./gradlew :backend:services:entries:entries-service:test --rerun-tasks` → **BUILD SUCCESSFUL**, alle 5 Tests grün (inkl. `DomainHierarchyMigrationTest` und `EntriesIsolationIntegrationTest` mit echtem PostgreSQL via Testcontainers).
|
||||
|
||||
---
|
||||
Gemini
|
||||
---
|
||||
|
||||
🏗️ [Lead Architect]
|
||||
|
||||
Das ist ein gewaltiger Meilenstein! Dass die Integrationstests mit echtem PostgreSQL (via Testcontainers) auf Anhieb grün sind, beweist, dass unser Fundament absolut solide ist. Die Datenbank, die Repositories und die Domain sprechen jetzt eine gemeinsame, saubere Sprache.
|
||||
|
||||
Damit ist das Backend unter der Haube bereit für das Tagesgeschäft der Meldestelle. Jetzt bringen wir diese Power an die Oberfläche!
|
||||
|
||||
Wir starten mit Phase 4 (API & Frontend-Wizard). Hier verknüpfen wir die neue Datenbankstruktur über REST-Schnittstellen mit unserem Compose Multiplatform Frontend und bauen genau den Wizard, den Sie aus dem alten "SuDo" kennen – nur moderner, intelligenter und mit unserer neuen Warn-Logik für Richter.
|
||||
|
||||
Hier ist der fertige Prompt für den nächsten Schritt. Kopieren Sie ihn einfach wieder und lassen Sie die Agenten zaubern:
|
||||
|
||||
```markdown
|
||||
# 🤖 Project Agents & Protocol: Phase 4 – API & Frontend-Wizard "Neuer Bewerb"
|
||||
|
||||
🏗️ **@Lead Architect**, 👷 **@Backend Developer** & 🎨 **@Frontend Expert**
|
||||
|
||||
Bitte führt gemeinsam die Phase 4 unseres Architektur-Updates durch. Das Backend (Domain & Persistenz) ist nun vollständig auf den neuen `Bewerb` (inkl. Zeitplan, Richter, Finanzen) vorbereitet. Jetzt müssen wir diese Daten über die API bereitstellen und den UI-Wizard für die Meldestelle bauen.
|
||||
|
||||
**Kontext:**
|
||||
Wir bauen den "Neuer Bewerb anlegen"-Wizard in Compose Multiplatform. Der Wizard soll den User intelligent durch den Prozess führen (angelehnt an Praxis-Anforderungen) und die neuen Datenstrukturen über aktualisierte DTOs an das Backend senden.
|
||||
|
||||
## 👷 Aufgaben für [Backend Developer]
|
||||
**1. API-DTOs aktualisieren (`.../api/dto/...` oder `.../controller/...`):**
|
||||
* Erweitere das `CreateBewerbRequest` (bzw. DTO) um alle neuen 16 Felder (z.B. `austragungsplatzId`, `beginnZeitTyp`, `startgeldCent`, `richterEinsaetze` etc.).
|
||||
* Erweitere das `BewerbResponse` DTO entsprechend.
|
||||
* Erstelle (falls nötig) ein `RichterEinsatzDto` (funktionaerId, position).
|
||||
|
||||
**2. Controller & UseCases anpassen:**
|
||||
* Aktualisiere das Mapping in den REST-Controllern oder UseCases, sodass die Werte aus dem Request korrekt in die `Bewerb`-Domain-Entität übersetzt und an das Repository übergeben werden.
|
||||
|
||||
## 🎨 Aufgaben für [Frontend Expert]
|
||||
**1. Compose Multiplatform UI - "Bewerb Wizard" (`.../frontend/.../ui/...`):**
|
||||
* Erstelle eine neue Composable `CreateBewerbWizardScreen` (oder passe eine bestehende an).
|
||||
* Gliedere die UI in logische Abschnitte (Tabs, Steps oder übersichtliche Cards):
|
||||
* **Step 1: Identifikation:** Sparte, Kategorie, Klasse/Höhe, Bewerbsnummer, Bezeichnung.
|
||||
* **Step 2: Details & Finanzen:** Beschreibung, Aufgabe (z.B. "R1"), Startgeld, Checkbox "Geldpreis ausbezahlt".
|
||||
* **Step 3: Ort & Zeitplan:** Dropdown für Austragungsplatz (optional), Beginn (Fix/Anschließend), Zeiten (Uhrzeit, Reitdauer, Umbau, Besichtigung).
|
||||
* **Step 4: Richter & Teilung:** Liste für Richterzuweisung (inkl. Dropdown für Position wie "C", "M") und Auswahl der Teilungsregel (`AbteilungsTeilungsTypE`, inkl. `MANUELL`).
|
||||
|
||||
**2. State-Management & API-Client:**
|
||||
* Erweitere den Ktor-Client (oder das genutzte HTTP-Framework) im Frontend, um das neue, große JSON-Payload an den Backend-Endpunkt zu senden.
|
||||
* Implementiere eine einfache "Warn-Logik" im UI-State für Step 4: Wenn ein Richter ausgewählt wird, zeige visuell (z.B. gelbes Icon/Text), dass der Turnierbeauftragte (TB) dies absegnen muss, falls die Qualifikation (mock-bar für jetzt) nicht optimal ist.
|
||||
|
||||
Bitte meldet euch mit einem Summary zurück, sobald die DTOs erweitert sind und das Grundgerüst des Compose-Wizards steht und erfolgreich baut!
|
||||
```
|
||||
|
||||
---
|
||||
Junie
|
||||
---
|
||||
|
||||
```markdown
|
||||
### Summary
|
||||
- API-DTOs für Bewerb erweitert (inkl. Zeitplan, Richter, Finanzen) und Controller/Service-Mapping angepasst.
|
||||
- Compose Multiplatform Wizard „Neuen Bewerb anlegen“ als Grundgerüst mit 4 Schritten erstellt; Frontend-Ktor-Client zum Senden des großen Payloads implementiert.
|
||||
|
||||
### Changes
|
||||
- Backend: `CreateBewerbRequest`, `UpdateBewerbRequest`, `BewerbResponse`, `RichterEinsatzDto` in `BewerbeController.kt` hinzugefügt und Endpoints auf DTOs umgestellt (List/Get/Create/Update → Response-Mapping).
|
||||
- Backend: `BewerbService.create(...)` und `update(...)` akzeptieren nun die neuen DTOs und mappen alle Felder (Beschreibung, Aufgabe, Austragungsplatz, Zeitplan, Finanzen, RichterEinsätze) auf die Repo-Entität.
|
||||
- Frontend: Neuer Ktor-Client `BewerbApi` mit `CreateBewerbPayload`/`BewerbResponse` (kotlinx.serialization) zum POST auf `/turniere/{turnierId}/bewerbe`.
|
||||
- Frontend: Neue Composable `CreateBewerbWizardScreen` mit 4 Steps, State-Holder und einfacher TB-Warnlogik bei Richterauswahl; Mapping von UI-State → API-Payload.
|
||||
|
||||
### Verification
|
||||
- Voller Projekt-Build erfolgreich (Backend und Frontend bauen grün).
|
||||
|
||||
### Notes
|
||||
- Teilungsregel (`AbteilungsTeilungsTypE`) ist aktuell im UI erfasst, wird aber backendseitig in diesem Endpoint noch nicht persistiert (Service-Repo-Modell enthält das Feld nicht). Follow-up möglich, sobald Backend-API dafür vorgesehen ist.
|
||||
```
|
||||
|
||||
---
|
||||
Gemini
|
||||
---
|
||||
|
||||
🏗️ [Lead Architect]
|
||||
|
||||
Das ist ein herausragendes Ergebnis! Ein kompletter Durchstich von der Datenbank bis zur Compose Multiplatform UI in so kurzer Zeit ist bemerkenswert. Der "Neuer Bewerb"-Wizard steht, das Datenmodell ist massiv gewachsen und die Architektur bleibt dank der sauberen Schichten (Clean Architecture) stabil und testbar.
|
||||
|
||||
### Zu Ihrer Notiz (AbteilungsTeilungsTypE):
|
||||
|
||||
Dass dieses Feld im Backend-Service/Repo noch nicht persistiert wird, ist ein klassischer Fall von "im Eifer des Gefechts übersehen". Das ist aber unser wichtigstes Feld für die Meldestelle (wie Sie anfangs sagten: Hier passieren die meisten Fehler)!
|
||||
|
||||
Bevor wir uns in das nächste große Thema stürzen (die Nennungen und das Teilnehmerkonto), sollten wir diesen "Hotfix" noch schnell einschieben, damit der Bewerb wirklich 100 % vollständig gespeichert wird.
|
||||
|
||||
Hier ist ein kurzer Prompt für den Backend Developer, um diese Lücke zu schließen. Danach können wir uns der Frage widmen: Wie kommt jetzt der Reiter mit seinem Pferd in diesen Bewerb?
|
||||
|
||||
```markdown
|
||||
# 🤖 Project Agents & Protocol: Phase 4.1 – Hotfix Teilungsregel
|
||||
|
||||
👷 **@Backend Developer**
|
||||
|
||||
Bitte schließe die kleine Lücke aus Phase 4. Der `AbteilungsTeilungsTypE` (inkl. `MANUELL`) wird aktuell vom Frontend gesendet, aber im Backend noch nicht persistiert.
|
||||
|
||||
**Aufgaben:**
|
||||
1. **Domain & DTOs:** Stelle sicher, dass `teilungsTyp: AbteilungsTeilungsTypE` (oder ähnlich) im `Bewerb`-Domain-Modell und in den Request/Response-DTOs (`CreateBewerbRequest`, `BewerbResponse`) vorhanden ist.
|
||||
2. **Infrastruktur (`BewerbTable.kt` & Flyway):**
|
||||
- Füge die Spalte `teilungs_typ` (varchar) zur `BewerbTable` hinzu.
|
||||
- Erstelle eine kleine Flyway-Migration (z.B. `V6__add_bewerb_teilungstyp.sql`), um die Spalte in der Datenbank zu ergänzen.
|
||||
3. **Repository (`BewerbRepositoryImpl.kt`):** Passe die `Insert`-, `Update`- und `rowToBewerb`-Methoden an, damit der `teilungsTyp` in der Datenbank gespeichert und wieder ausgelesen wird.
|
||||
4. **Service-Mapping:** Stelle sicher, dass der Controller/Service diesen Wert vom Request-DTO in die Domain-Entität übernimmt.
|
||||
|
||||
Bitte bestätige kurz, wenn das Feld durchgängig von der API bis zur DB gespeichert wird und das Projekt erfolgreich baut!
|
||||
```
|
||||
|
||||
Sobald dieser Hotfix durch ist, haben wir das perfekte Fundament für Turniere und Bewerbe.
|
||||
|
||||
**Ausblick auf den nächsten Stint:** Wenn das Turnier und die Bewerbe (Prüfungen) stehen, öffnet der Veranstalter die Tore für die Nennungen. Hier kommt Ihre Vision ins Spiel: Das datenschutzkonforme Web-Formular für lizenzfreie Reiter und der Import der n2-xxxxx.dat für die Verbands-Reiter. Wollen wir uns als Nächstes ansehen, wie eine Nennung (Reiter + Pferd + Bewerb + Nenngeld) architektonisch in unserem System landet und validiert wird?
|
||||
|
||||
---
|
||||
Junie
|
||||
---
|
||||
|
||||
Hier noch der letzte Summary von Junie:
|
||||
|
||||
```markdown
|
||||
### Summary
|
||||
- Hotfix umgesetzt: `teilungsTyp (AbteilungsTeilungsTypE)` wird nun von der API bis zur Datenbank vollständig persistiert.
|
||||
- Projekt baut erfolgreich (Backend/Frontend grün).
|
||||
|
||||
### Changes
|
||||
- DTOs erweitert: `CreateBewerbRequest`, `UpdateBewerbRequest`, `BewerbResponse` inkl. Feld `teilungsTyp` (+ Mapping in Controller).
|
||||
- Service angepasst: `BewerbService.create/update` übernehmen `teilungsTyp` in das Service-Modell.
|
||||
- Repository: Service‑Modell `Bewerb` um `teilungsTyp` ergänzt; `BewerbRepositoryImpl` liest/schreibt `teilungs_typ` (row→enum, insert/update via `name`).
|
||||
- Infrastruktur: `BewerbTable` um Spalte `teilungs_typ` erweitert; neue Flyway‑Migration `V6__add_bewerb_teilungstyp.sql` (Spalte + Index).
|
||||
|
||||
### Verification
|
||||
- Voller Build erfolgreich (Gradle Build „BUILD SUCCESSFUL“). Datenfluss API → Repo → DB ist kompilierbar und konsistent.
|
||||
|
||||
### Notes
|
||||
- `teilungsTyp` ist optional (nullable) modelliert; Werte entsprechen `AbteilungsTeilungsTypE` (inkl. `MANUELL`).
|
||||
```
|
||||
|
||||
Bevor wir weiter machen will ich das du dir unseren Gradle-Build genauer unter die Lupe nimmst.
|
||||
|
||||
---
|
||||
Gemini
|
||||
---
|
||||
|
||||
🏗️ [Lead Architect]
|
||||
|
||||
Absolut. Eine saubere und verständliche Build-Logik ist das Rückgrat eines professionellen Projekts. Ich habe mir die `settings.gradle.kts` und die Verzeichnisstruktur angesehen und dabei eine kritische Lücke entdeckt, die perfekt zu der Notiz aus dem letzten Summary passt:
|
||||
|
||||
**Problem:** Der gesamte events-Service (`:backend:services:events:*`) ist nicht im Gradle-Build (`settings.gradle.kts`) registriert.
|
||||
|
||||
Das bedeutet:
|
||||
- Die Module `events-domain`, `events-api`, `events-service` etc. werden aktuell nicht kompiliert, nicht getestet und nicht als Teil des Gesamtsystems gebaut.
|
||||
- Wir haben dort zwar Code-Dateien angelegt (Turnier.kt, Austragungsplatz.kt), aber sie sind für den Rest der Anwendung quasi unsichtbar.
|
||||
- Dies erklärt, warum die Umbenennungen und Erweiterungen in diesem Bereich keine Kompilierfehler erzeugt haben – der Compiler hat sie nie gesehen.
|
||||
|
||||
**Lösung:** Wir müssen die `events`-Module in der `settings.gradle.kts` explizit einbinden, genau wie es bei den anderen Services (`entries`, `identity` etc.) bereits der Fall ist.
|
||||
|
||||
Ich werde jetzt die `settings.gradle.kts` anpassen, um diese Lücke zu schließen.
|
||||
|
||||
---
|
||||
Ich
|
||||
---
|
||||
|
||||
Ja, bitte
|
||||
|
|
|
|||
|
|
@ -75,6 +75,13 @@ include(":backend:services:entries:entries-api")
|
|||
include(":backend:services:entries:entries-domain")
|
||||
include(":backend:services:entries:entries-service")
|
||||
|
||||
// --- EVENTS (Veranstaltungen & Turniere) ---
|
||||
include(":backend:services:events:events-api")
|
||||
include(":backend:services:events:events-common")
|
||||
include(":backend:services:events:events-domain")
|
||||
include(":backend:services:events:events-infrastructure")
|
||||
include(":backend:services:events:events-service")
|
||||
|
||||
// --- IDENTITY (Benutzerprofile & ZNS-Link) ---
|
||||
include(":backend:services:identity:identity-domain")
|
||||
include(":backend:services:identity:identity-infrastructure")
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user