chore(ci): Align GH Workflows with Docker SSoT, new paths; minimal SSoT guard; staticAnalysis (#23)

* chore(MP-21): snapshot pre-refactor state (Epic 1) * chore(MP-22): scaffold new repo structure, relocate Docker Compose, move frontend/backend modules, update Makefile; add docs mapping and env template * MP-22 Epic 2: Erfolgreich umgesetzt und verifiziert * MP-23 Epic 3: Gradle/Build Governance zentralisieren * MP-23 Epic 3: Gradle/Build Governance zentralisieren * chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt - ENV Single Source of Truth - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides) - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example]) - Docker Compose vereinheitlicht (docker/docker-compose.yaml) - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf) und Start mit -c config_file=/etc/postgresql/postgresql.conf - Redis: zentralen redis.conf mounten (../config/redis/redis.conf) und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}" - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro) - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT - Frontend/DI/Network (MP-23 Grundlage) - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging) - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin) - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback) - Build/Gradle & Module-Refs - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht - Dockerfiles angepasst - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service - Static Analysis / Guards - config/detekt/detekt.yml hinzugefügt - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet - Doku - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt - docs/adr/README.md angelegt BREAKING CHANGES: - Makefile komplett entfernt (bitte direkt `docker compose` verwenden) - ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root) - Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root) Verifikation (lokal): - ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen) - Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config` - Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app` - Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain` Refs: MP-22 (Epic 2), MP-23 (Epic 3) * chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt - ENV Single Source of Truth - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides) - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example]) - Docker Compose vereinheitlicht (docker/docker-compose.yaml) - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf) und Start mit -c config_file=/etc/postgresql/postgresql.conf - Redis: zentralen redis.conf mounten (../config/redis/redis.conf) und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}" - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro) - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT - Frontend/DI/Network (MP-23 Grundlage) - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging) - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin) - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback) - Build/Gradle & Module-Refs - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht - Dockerfiles angepasst - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service - Static Analysis / Guards - config/detekt/detekt.yml hinzugefügt - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet - Doku - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt - docs/adr/README.md angelegt BREAKING CHANGES: - Makefile komplett entfernt (bitte direkt `docker compose` verwenden) - ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root) - Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root) Verifikation (lokal): - ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen) - Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config` - Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app` - Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain` Refs: MP-22 (Epic 2), MP-23 (Epic 3) * chore(devops)!: Docker-SSoT (.env) konsolidiert, Compose-Mounts ergänzt, Makefile entfernt - ENV Single Source of Truth - docker/.env.example neu (inkl. REDIS_PASSWORD, Ports, Build-Overrides) - config/.env(.example) als DEPRECATED markiert (Verweis auf docker/.env[.example]) - Docker Compose vereinheitlicht (docker/docker-compose.yaml) - Postgres: zentralen postgresql.conf mounten (../config/postgres/postgresql.conf) und Start mit -c config_file=/etc/postgresql/postgresql.conf - Redis: zentralen redis.conf mounten (../config/redis/redis.conf) und Start via "redis-server … ${REDIS_PASSWORD:+--requirepass $REDIS_PASSWORD}" - Web-Nginx: ../config/nginx/nginx.prod.conf → /etc/nginx/nginx.conf (ro) - Monitoring: Prometheus/Grafana nutzen ../config/monitoring/* als SSoT - Frontend/DI/Network (MP-23 Grundlage) - :frontend:core:network Modul mit Koin `apiClient` (Ktor + JSON/Retry/Timeout/Logging) - Plattform-Basis-URL-Auflösung (JVM: ENV API_BASE_URL; JS: globalThis.API_BASE_URL / Same-Origin) - Web index.html setzt API_BASE_URL (Query `?apiBaseUrl=…` > Same-Origin > Fallback) - Build/Gradle & Module-Refs - settings.gradle.kts: neue Frontend-/Backend-Pfade bereits inkludiert - Features/Shell: Abhängigkeiten auf :frontend:shared / :frontend:core:* angepasst - Ping-API-Refs auf :backend:services:ping:ping-api vereinheitlicht - Dockerfiles angepasst - backend/infrastructure/gateway/Dockerfile → Tasks/Pfade auf :backend:gateway - backend/services/ping/Dockerfile → Tasks/Pfade auf :backend:services:ping:ping-service - Static Analysis / Guards - config/detekt/detekt.yml hinzugefügt - Leichter Arch-Guard (Frontend) gegen manuelle Authorization-Header vorbereitet - Doku - docs/ARCHITECTURE.md (Struktur, Mapping, Next Steps) ergänzt - docs/adr/README.md angelegt BREAKING CHANGES: - Makefile komplett entfernt (bitte direkt `docker compose` verwenden) - ENV-Quelle ist jetzt docker/.env (statt config/.env oder Root) - Compose-Datei unter docker/docker-compose.yaml (nicht mehr compose.yaml im Repo-Root) Verifikation (lokal): - ENV anlegen: `cp docker/.env.example docker/.env` (Werte anpassen) - Compose prüfen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml config` - Infrastruktur: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle up -d postgres redis keycloak web-app` - Services bauen: `docker compose --env-file docker/.env -f docker/docker-compose.yaml -p meldestelle build api-gateway ping-service --no-cache --progress=plain` Refs: MP-22 (Epic 2), MP-23 (Epic 3) * chore(ci): Workflows an Docker-SSoT & neue Struktur angepasst, minimaler SSoT-Guard - ssot-guard.yml: Option B (minimal) → `docker compose -f docker/docker-compose.yaml config` als Lint - integration-tests.yml: `./gradlew staticAnalysis` vor Integrationstests - docs-kdoc-sync.yml: Dokka-Task Fallback (dokkaGfmAll || dokkaGfm), YouTrack-Sync nur wenn Script vorhanden - deploy-proxmox.yml: Compose-Pfade auf docker/docker-compose.yaml + `--env-file docker/.env`; Build/Test Schritte vereinheitlicht - ci-main.yml: SSoT-Skripte per `if: hashFiles(...)` guarded, Compose-Lint Fallback; OpenAPI‑Pfad → backend/gateway; ADR‑Pfade → docs/adr/**; `staticAnalysis` in Build integriert - youtrack-sync.yml: unverändert (funktional) Refs: MP-22, MP-23 * chore(ci): Workflows an Docker-SSoT & neue Struktur angepasst, minimaler SSoT-Guard - ssot-guard.yml: Option B (minimal) → `docker compose -f docker/docker-compose.yaml config` als Lint - integration-tests.yml: `./gradlew staticAnalysis` vor Integrationstests - docs-kdoc-sync.yml: Dokka-Task Fallback (dokkaGfmAll || dokkaGfm), YouTrack-Sync nur wenn Script vorhanden - deploy-proxmox.yml: Compose-Pfade auf docker/docker-compose.yaml + `--env-file docker/.env`; Build/Test Schritte vereinheitlicht - ci-main.yml: SSoT-Skripte per `if: hashFiles(...)` guarded, Compose-Lint Fallback; OpenAPI‑Pfad → backend/gateway; ADR‑Pfade → docs/adr/**; `staticAnalysis` in Build integriert - youtrack-sync.yml: unverändert (funktional) Refs: MP-22, MP-23 * fix(ci): create .env from example before validating compose config * fix(ci): update ssot-guard filename (.yaml) and sync workflow state * fixing * fix(webpack): correct sql.js fallback configuration for webpack 5
2025-12-03 12:03:40 +01:00
parent 034892e890
commit 95fe3e0573
365 changed files with 2283 additions and 15142 deletions
@@ -0,0 +1,38 @@
+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)
+}
+
+application {
+    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)
+
+    testImplementation(projects.platform.platformTesting)
+    testImplementation(libs.ktor.server.tests)
+}
@@ -0,0 +1,333 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+package at.mocode.events.api.rest
+
+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.*
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.datetime.LocalDate
+import kotlinx.serialization.Serializable
+
+/**
+ * REST API controller for event management operations.
+ *
+ * This controller provides HTTP endpoints for all event-related operations
+ * following REST conventions and proper HTTP status codes.
+ */
+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.
+     */
+    fun configureRoutes(routing: Routing) {
+        routing.route("/api/events") {
+
+            // 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")
+                        )
+                    }
+                    val searchTerm = call.request.queryParameters["search"]
+                    val publicOnly = call.request.queryParameters["publicOnly"]?.toBoolean() ?: false
+                    val startDate = call.request.queryParameters["startDate"]?.let { LocalDate.parse(it) }
+                    val endDate = call.request.queryParameters["endDate"]?.let { LocalDate.parse(it) }
+
+                    val events = when {
+                        searchTerm != null -> veranstaltungRepository.findByName(searchTerm, limit)
+                        organizerId != null -> veranstaltungRepository.findByVeranstalterVereinId(organizerId, activeOnly)
+                        publicOnly -> veranstaltungRepository.findPublicEvents(activeOnly)
+                        startDate != null && endDate != null -> veranstaltungRepository.findByDateRange(startDate, endDate, activeOnly)
+                        startDate != null -> veranstaltungRepository.findByStartDate(startDate, activeOnly)
+                        else -> veranstaltungRepository.findAllActive(limit, offset)
+                    }
+
+                    call.respond(HttpStatusCode.OK, ApiResponse.success(events))
+                } catch (e: Exception) {
+                    call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to retrieve events: ${e.message}"))
+                }
+            }
+
+            // GET /api/events/{id} - Get event by ID
+            get("/{id}") {
+                try {
+                    val eventId = Uuid.parse(call.parameters["id"]!!)
+                    val request = GetVeranstaltungUseCase.GetVeranstaltungRequest(eventId)
+                    val response = getVeranstaltungUseCase.execute(request)
+
+                    if (response.success && response.data != null) {
+                        call.respond(HttpStatusCode.OK, ApiResponse.success((response.data as GetVeranstaltungUseCase.GetVeranstaltungResponse).veranstaltung))
+                    } else {
+                        call.respond(HttpStatusCode.NotFound, ApiResponse.error<Any>("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 retrieve event: ${e.message}"))
+                }
+            }
+
+            // GET /api/events/stats - Get event statistics
+            get("/stats") {
+                try {
+                    val activeCount = veranstaltungRepository.countActive()
+                    val publicCount = veranstaltungRepository.findPublicEvents(true).size
+
+                    val stats = EventStats(
+                        totalActive = activeCount,
+                        totalPublic = publicCount.toLong()
+                    )
+
+                    call.respond(HttpStatusCode.OK, ApiResponse.success(stats))
+                } catch (e: Exception) {
+                    call.respond(HttpStatusCode.InternalServerError, ApiResponse.error<Any>("Failed to retrieve event statistics: ${e.message}"))
+                }
+            }
+
+            // POST /api/events - Create new event
+            post {
+                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(
+                        name = createRequest.name,
+                        beschreibung = createRequest.beschreibung,
+                        startDatum = createRequest.startDatum,
+                        endDatum = createRequest.endDatum,
+                        ort = createRequest.ort,
+                        veranstalterVereinId = createRequest.veranstalterVereinId,
+                        sparten = createRequest.sparten,
+                        istAktiv = createRequest.istAktiv,
+                        istOeffentlich = createRequest.istOeffentlich,
+                        maxTeilnehmer = createRequest.maxTeilnehmer,
+                        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"))
+                    }
+                } catch (e: Exception) {
+                    call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid request data: ${e.message}"))
+                }
+            }
+
+            // PUT /api/events/{id} - Update event
+            put("/{id}") {
+                try {
+                    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))
+                        )
+                        return@put
+                    }
+
+                    val useCaseRequest = UpdateVeranstaltungUseCase.UpdateVeranstaltungRequest(
+                        veranstaltungId = eventId,
+                        name = updateRequest.name,
+                        beschreibung = updateRequest.beschreibung,
+                        startDatum = updateRequest.startDatum,
+                        endDatum = updateRequest.endDatum,
+                        ort = updateRequest.ort,
+                        veranstalterVereinId = updateRequest.veranstalterVereinId,
+                        sparten = updateRequest.sparten,
+                        istAktiv = updateRequest.istAktiv,
+                        istOeffentlich = updateRequest.istOeffentlich,
+                        maxTeilnehmer = updateRequest.maxTeilnehmer,
+                        anmeldeschluss = updateRequest.anmeldeschluss
+                    )
+
+                    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"))
+                    }
+                } catch (_: IllegalArgumentException) {
+                    call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("Invalid event ID format"))
+                } catch (e: Exception) {
+                    call.respond(HttpStatusCode.BadRequest, ApiResponse.error<Any>("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 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"))
+                    }
+                } 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}"))
+                }
+            }
+        }
+    }
+
+    /**
+     * Request DTO for creating events.
+     */
+    @Serializable
+    data class CreateEventRequest(
+        val name: String,
+        val beschreibung: String? = null,
+        val startDatum: LocalDate,
+        val endDatum: LocalDate,
+        val ort: String,
+        @Serializable(with = UuidSerializer::class)
+        val veranstalterVereinId: Uuid,
+        val sparten: List<SparteE> = emptyList(),
+        val istAktiv: Boolean = true,
+        val istOeffentlich: Boolean = true,
+        val maxTeilnehmer: Int? = null,
+        val anmeldeschluss: LocalDate? = null
+    )
+
+    /**
+     * Request DTO for updating events.
+     */
+    @Serializable
+    data class UpdateEventRequest(
+        val name: String,
+        val beschreibung: String? = null,
+        val startDatum: LocalDate,
+        val endDatum: LocalDate,
+        val ort: String,
+        @Serializable(with = UuidSerializer::class)
+        val veranstalterVereinId: Uuid,
+        val sparten: List<SparteE> = emptyList(),
+        val istAktiv: Boolean = true,
+        val istOeffentlich: Boolean = true,
+        val maxTeilnehmer: Int? = null,
+        val anmeldeschluss: LocalDate? = null
+    )
+
+    /**
+     * Response DTO for event statistics.
+     */
+    @Serializable
+    data class EventStats(
+        val totalActive: Long,
+        val totalPublic: Long
+    )
+}