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

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

@@ -0,0 +1,24 @@
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.spring)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.ktor)
+    application
+}
+
+dependencies {
+    implementation(projects.platform.platformDependencies)
+
+    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.spring.boot.starter.data.jpa)
+    implementation(libs.postgresql.driver)
+
+    testImplementation(projects.platform.platformTesting)
+}

backend/services/events/events-infrastructure/src/main/kotlin/at/mocode/events/infrastructure/persistence/VeranstaltungRepositoryImpl.kt

@@ -0,0 +1,189 @@
+@file:OptIn(kotlin.uuid.ExperimentalUuidApi::class)
+package at.mocode.events.infrastructure.persistence
+
+import at.mocode.core.domain.model.SparteE
+import at.mocode.events.domain.model.Veranstaltung
+import at.mocode.events.domain.repository.VeranstaltungRepository
+import at.mocode.core.utils.database.DatabaseFactory
+import kotlin.uuid.Uuid
+import kotlinx.datetime.Clock
+import kotlinx.datetime.LocalDate
+import kotlinx.serialization.json.Json
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.statements.UpdateBuilder
+
+/**
+ * Exposed-based implementation of VeranstaltungRepository.
+ *
+ * This implementation provides data persistence for Veranstaltung entities
+ * using the Exposed SQL framework and PostgreSQL database.
+ */
+class VeranstaltungRepositoryImpl : VeranstaltungRepository {
+
+    override suspend fun findById(id: Uuid): Veranstaltung? = DatabaseFactory.dbQuery {
+        VeranstaltungTable.selectAll().where { VeranstaltungTable.id eq id }
+            .map { rowToVeranstaltung(it) }
+            .singleOrNull()
+    }
+
+    override suspend fun findByName(searchTerm: String, limit: Int): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        val searchPattern = "%$searchTerm%"
+        VeranstaltungTable.selectAll().where { VeranstaltungTable.name like searchPattern }
+            .orderBy(VeranstaltungTable.startDatum, SortOrder.DESC)
+            .limit(limit)
+            .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun findByVeranstalterVereinId(vereinId: Uuid, activeOnly: Boolean): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        val query = VeranstaltungTable.selectAll().where { VeranstaltungTable.veranstalterVereinId eq vereinId }
+
+        if (activeOnly) {
+            query.andWhere { VeranstaltungTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(VeranstaltungTable.startDatum, SortOrder.DESC)
+         .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun findByDateRange(startDate: LocalDate, endDate: LocalDate, activeOnly: Boolean): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        val query = VeranstaltungTable.selectAll().where {
+            (VeranstaltungTable.startDatum greaterEq startDate) and
+                (VeranstaltungTable.endDatum lessEq endDate)
+        }
+
+        if (activeOnly) {
+            query.andWhere { VeranstaltungTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(VeranstaltungTable.startDatum)
+         .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun findByStartDate(date: LocalDate, activeOnly: Boolean): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        val query = VeranstaltungTable.selectAll().where { VeranstaltungTable.startDatum eq date }
+
+        if (activeOnly) {
+            query.andWhere { VeranstaltungTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(VeranstaltungTable.name)
+         .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun findAllActive(limit: Int, offset: Int): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        VeranstaltungTable.selectAll().where { VeranstaltungTable.istAktiv eq true }
+            .orderBy(VeranstaltungTable.startDatum, SortOrder.DESC)
+            .limit(limit, offset.toLong())
+            .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun findPublicEvents(activeOnly: Boolean): List<Veranstaltung> = DatabaseFactory.dbQuery {
+        val query = VeranstaltungTable.selectAll().where { VeranstaltungTable.istOeffentlich eq true }
+
+        if (activeOnly) {
+            query.andWhere { VeranstaltungTable.istAktiv eq true }
+        } else {
+            query
+        }.orderBy(VeranstaltungTable.startDatum, SortOrder.DESC)
+         .map { rowToVeranstaltung(it) }
+    }
+
+    override suspend fun save(veranstaltung: Veranstaltung): Veranstaltung = DatabaseFactory.dbQuery {
+        val now = Clock.System.now()
+        val updatedVeranstaltung = veranstaltung.copy(updatedAt = now)
+
+        // Check if a record exists
+        val existingRecord = VeranstaltungTable.selectAll()
+            .where { VeranstaltungTable.id eq veranstaltung.veranstaltungId }
+            .singleOrNull()
+
+        if (existingRecord != null) {
+            // Update existing record
+            VeranstaltungTable.update({ VeranstaltungTable.id eq veranstaltung.veranstaltungId }) {
+                veranstaltungToStatement(it, updatedVeranstaltung)
+            }
+            updatedVeranstaltung
+        } else {
+            // Insert a new record
+            VeranstaltungTable.insert {
+                it[id] = veranstaltung.veranstaltungId
+                veranstaltungToStatement(it, updatedVeranstaltung)
+            }
+            updatedVeranstaltung
+        }
+    }
+
+    override suspend fun delete(id: Uuid): Boolean = DatabaseFactory.dbQuery {
+        val deletedRows = VeranstaltungTable.deleteWhere { VeranstaltungTable.id eq id }
+        deletedRows > 0
+    }
+
+    override suspend fun countActive(): Long = DatabaseFactory.dbQuery {
+        VeranstaltungTable.selectAll().where { VeranstaltungTable.istAktiv eq true }
+            .count()
+    }
+
+    override suspend fun countByVeranstalterVereinId(vereinId: Uuid, activeOnly: Boolean): Long = DatabaseFactory.dbQuery {
+        val query = VeranstaltungTable.selectAll().where { VeranstaltungTable.veranstalterVereinId eq vereinId }
+
+        if (activeOnly) {
+            query.andWhere { VeranstaltungTable.istAktiv eq true }
+        } else {
+            query
+        }.count()
+    }
+
+    /**
+     * Converts a database row to a Veranstaltung domain object.
+     */
+    private fun rowToVeranstaltung(row: ResultRow): Veranstaltung {
+        // Parse sparten from JSON string
+        val spartenJson = row[VeranstaltungTable.sparten]
+        val sparten = if (spartenJson.isNotBlank()) {
+            try {
+                Json.decodeFromString<List<SparteE>>(spartenJson)
+            } catch (_: Exception) {
+                emptyList()
+            }
+        } else {
+            emptyList()
+        }
+
+        return Veranstaltung(
+            veranstaltungId = row[VeranstaltungTable.id].value,
+            name = row[VeranstaltungTable.name],
+            beschreibung = row[VeranstaltungTable.beschreibung],
+            startDatum = row[VeranstaltungTable.startDatum],
+            endDatum = row[VeranstaltungTable.endDatum],
+            ort = row[VeranstaltungTable.ort],
+            veranstalterVereinId = row[VeranstaltungTable.veranstalterVereinId],
+            sparten = sparten,
+            istAktiv = row[VeranstaltungTable.istAktiv],
+            istOeffentlich = row[VeranstaltungTable.istOeffentlich],
+            maxTeilnehmer = row[VeranstaltungTable.maxTeilnehmer],
+            anmeldeschluss = row[VeranstaltungTable.anmeldeschluss],
+            createdAt = row[VeranstaltungTable.createdAt],
+            updatedAt = row[VeranstaltungTable.updatedAt]
+        )
+    }
+
+    /**
+     * Maps a Veranstaltung domain object to database statement values.
+     */
+    private fun veranstaltungToStatement(statement: UpdateBuilder<*>, veranstaltung: Veranstaltung) {
+        statement[VeranstaltungTable.name] = veranstaltung.name
+        statement[VeranstaltungTable.beschreibung] = veranstaltung.beschreibung
+        statement[VeranstaltungTable.startDatum] = veranstaltung.startDatum
+        statement[VeranstaltungTable.endDatum] = veranstaltung.endDatum
+        statement[VeranstaltungTable.ort] = veranstaltung.ort
+        statement[VeranstaltungTable.veranstalterVereinId] = veranstaltung.veranstalterVereinId
+        statement[VeranstaltungTable.sparten] = Json.encodeToString(veranstaltung.sparten)
+        statement[VeranstaltungTable.istAktiv] = veranstaltung.istAktiv
+        statement[VeranstaltungTable.istOeffentlich] = veranstaltung.istOeffentlich
+        statement[VeranstaltungTable.maxTeilnehmer] = veranstaltung.maxTeilnehmer
+        statement[VeranstaltungTable.anmeldeschluss] = veranstaltung.anmeldeschluss
+        statement[VeranstaltungTable.createdAt] = veranstaltung.createdAt
+        statement[VeranstaltungTable.updatedAt] = veranstaltung.updatedAt
+    }
+}

backend/services/events/events-infrastructure/src/main/kotlin/at/mocode/events/infrastructure/persistence/VeranstaltungTable.kt

@@ -0,0 +1,48 @@
+package at.mocode.events.infrastructure.persistence
+
+import at.mocode.core.domain.model.SparteE
+import org.jetbrains.exposed.dao.id.UUIDTable
+import org.jetbrains.exposed.sql.kotlin.datetime.date
+import org.jetbrains.exposed.sql.kotlin.datetime.timestamp
+
+/**
+ * Database table definition for events (Veranstaltung) in the event-management context.
+ *
+ * This table stores all event information including dates, location,
+ * organization details, and administrative information.
+ */
+object VeranstaltungTable : UUIDTable("veranstaltungen") {
+
+    // Basic Information
+    val name = varchar("name", 255)
+    val beschreibung = text("beschreibung").nullable()
+
+    // Dates
+    val startDatum = date("start_datum")
+    val endDatum = date("end_datum")
+    val anmeldeschluss = date("anmeldeschluss").nullable()
+
+    // Location and Organization
+    val ort = varchar("ort", 255)
+    val veranstalterVereinId = uuid("veranstalter_verein_id")
+
+    // Event Details
+    val sparten = text("sparten") // JSON array of SparteE values
+    val istAktiv = bool("ist_aktiv").default(true)
+    val istOeffentlich = bool("ist_oeffentlich").default(true)
+    val maxTeilnehmer = integer("max_teilnehmer").nullable()
+
+    // Audit Fields
+    val createdAt = timestamp("created_at")
+    val updatedAt = timestamp("updated_at")
+
+    init {
+        // Indexes for performance
+        index(false, name)
+        index(false, startDatum)
+        index(false, endDatum)
+        index(false, veranstalterVereinId)
+        index(false, istAktiv)
+        index(false, istOeffentlich)
+    }
+}