mocode-software/meldestelle
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: Migrate from monolithic to modular architecture

Browse Source 
1. **Docker-Compose für Entwicklung optimieren**
2. **Umgebungsvariablen für lokale Entwicklung**
3. **Service-Abhängigkeiten**
4. **Docker-Compose für Produktion**
5. **Dokumentation**
This commit is contained in:
stefan
2025-07-24 15:26:36 +02:00
parent e7b18da45d
commit dbbc303068
18 changed files with 56 additions and 5233 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Dockerfile
+34 -22
View File
@@ -1,5 +1,5 @@
# ----------- Stage 1: Build Stage -----------
FROM gradle:8.14-jdk21 AS build
FROM gradle:8.14.3-jdk21 AS build
WORKDIR /home/gradle/src
# Copy only the files needed for dependency resolution first
@@ -7,28 +7,30 @@ WORKDIR /home/gradle/src
COPY build.gradle.kts settings.gradle.kts gradle.properties ./
COPY gradle ./gradle
# Download dependencies and cache them
RUN gradle dependencies --no-daemon
# Download dependencies and cache them in separate layer
RUN gradle dependencies --no-daemon --quiet
# Copy source code
COPY shared-kernel ./shared-kernel
COPY api-gateway ./api-gateway
COPY master-data ./master-data
COPY member-management ./member-management
COPY horse-registry ./horse-registry
COPY event-management ./event-management
COPY composeApp ./composeApp
COPY server ./server
# Copy source code in order of change frequency (least to most likely to change)
COPY core ./core
COPY platform ./platform
COPY infrastructure ./infrastructure
COPY masterdata ./masterdata
COPY members ./members
COPY horses ./horses
COPY events ./events
# Build with optimized settings
RUN gradle :api-gateway:shadowJar --no-daemon --parallel --build-cache
RUN gradle :infrastructure:gateway:shadowJar --no-daemon --parallel --build-cache --quiet
# ----------- Stage 2: Runtime Stage -----------
FROM openjdk:21-slim-bookworm AS runtime
FROM eclipse-temurin:21-jre-alpine AS runtime
# Install curl for health checks and ca-certificates for SSL
RUN apk add --no-cache curl ca-certificates tzdata
# Add non-root user for security
RUN addgroup --system --gid 1001 appuser && \
adduser --system --uid 1001 --gid 1001 appuser
RUN addgroup -g 1001 -S appuser && \
adduser -u 1001 -S appuser -G appuser
# Set timezone
ENV TZ=Europe/Vienna
@@ -37,7 +39,7 @@ RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
WORKDIR /app
# Copy the jar file from the build stage
COPY --from=build /home/gradle/src/api-gateway/build/libs/*.jar ./app.jar
COPY --from=build /home/gradle/src/infrastructure/gateway/build/libs/*.jar ./app.jar
# Set ownership to non-root user
RUN chown -R appuser:appuser /app
@@ -45,26 +47,36 @@ RUN chown -R appuser:appuser /app
# Switch to non-root user
USER appuser
# Add metadata labels
# Add metadata labels (OCI Image Format Specification)
LABEL org.opencontainers.image.title="Meldestelle API Gateway"
LABEL org.opencontainers.image.description="API Gateway for Meldestelle application"
LABEL org.opencontainers.image.description="API Gateway for Meldestelle horse sport registration system"
LABEL org.opencontainers.image.vendor="MoCode"
LABEL org.opencontainers.image.version="1.0.0"
LABEL org.opencontainers.image.created="2025-07-21"
LABEL org.opencontainers.image.created="2025-07-24"
LABEL org.opencontainers.image.source="https://github.com/mocode/meldestelle"
LABEL org.opencontainers.image.documentation="https://github.com/mocode/meldestelle/blob/main/README.md"
LABEL org.opencontainers.image.licenses="MIT"
# Expose the application port
EXPOSE 8081
# Define health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
CMD curl -f http://localhost:8081/health || exit 1
# Run the application with optimized JVM settings
# Run the application with optimized JVM settings for containerized environment
ENTRYPOINT ["java", \
"-XX:+UseContainerSupport", \
"-XX:MaxRAMPercentage=75.0", \
"-XX:+UseG1GC", \
"-XX:MaxGCPauseMillis=100", \
"-XX:+ParallelRefProcEnabled", \
"-XX:+HeapDumpOnOutOfMemoryError", \
"-XX:HeapDumpPath=/tmp/heapdump.hprof", \
"-XX:+ExitOnOutOfMemoryError", \
"-XX:+UnlockExperimentalVMOptions", \
"-XX:+UseCGroupMemoryLimitForHeap", \
"-Djava.security.egd=file:/dev/./urandom", \
"-Dfile.encoding=UTF-8", \
"-Duser.timezone=Europe/Vienna", \
"-jar", "/app/app.jar"]
README.md
+1 -1
View File
@@ -9,7 +9,7 @@ Das Projekt wurde kürzlich auf eine modulare Architektur migriert, um die Wartb
## Systemanforderungen
- Java 21
- Kotlin 2.1.20
- Kotlin 2.1.21
- Gradle 8.14
- Docker und Docker Compose
build.gradle.kts
+2 -1
View File
@@ -64,8 +64,9 @@ subprojects {
// Include all tests that have "Integration" in their name
include("**/*Integration*Test.kt")
// Exclude tests that are not integration tests
// Exclude unit tests (but keep integration tests)
exclude("**/*Test.kt")
include("**/*IntegrationTest.kt")
// Set system properties for integration tests
systemProperty("spring.profiles.active", "integration-test")
client/common-ui/src/main/kotlin/at/mocode/client/common/components/events/EventComponent.kt.bak
-44
View File
@@ -1,44 +0,0 @@
package at.mocode.client.common.components.events
import at.mocode.events.domain.model.Veranstaltung
/**
* Simple JS-specific utility functions for event management UI
*/
object EventUIUtils {
/**
* Formats an event for display in the browser
*/
fun formatEventForDisplay(event: Veranstaltung): String {
return buildString {
append("Event: ${event.name}")
append(" | Location: ${event.ort}")
append(" | From: ${event.startDatum} to: ${event.endDatum}")
if (event.beschreibung != null) {
append(" | Description: ${event.beschreibung}")
}
if (event.sparten.isNotEmpty()) {
append(" | Sports: ${event.sparten.joinToString(", ") { it.name }}")
}
}
}
/**
* Creates a simple HTML representation of an event
*/
fun createEventHtml(event: Veranstaltung): String {
return """
<div class="event-card">
<h3>${event.name}</h3>
<p><strong>Location:</strong> ${event.ort}</p>
<p><strong>Date:</strong> ${event.startDatum} - ${event.endDatum}</p>
${if (event.beschreibung != null) "<p><strong>Description:</strong> ${event.beschreibung}</p>" else ""}
${if (event.sparten.isNotEmpty())
"<p><strong>Sports:</strong> ${event.sparten.joinToString(", ") { it.name }}</p>"
else ""}
</div>
""".trimIndent()
}
}
client/common-ui/src/main/kotlin/at/mocode/client/common/components/events/VeranstaltungsListe.kt.bak
-176
View File
@@ -1,176 +0,0 @@
package at.mocode.client.common.components.events
import at.mocode.events.domain.model.Veranstaltung
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import kotlinx.serialization.json.Json
import react.*
import react.dom.html.ReactHTML.div
import react.dom.html.ReactHTML.h1
import react.dom.html.ReactHTML.h3
import react.dom.html.ReactHTML.p
import react.dom.html.ReactHTML.span
import emotion.react.css
/**
* Props for the VeranstaltungsListe component
*/
external interface VeranstaltungsListeProps : Props
// Create Ktor client for API calls
private val apiClient = HttpClient {
install(ContentNegotiation) {
json(Json {
ignoreUnknownKeys = true
})
}
}
/**
* React component that displays a list of events (Veranstaltungen).
*
* This component loads event data from the API and renders it as HTML.
* Uses useState for state management and useEffectOnce for data loading.
*/
val VeranstaltungsListe = FC<VeranstaltungsListeProps> { _ ->
// State management with useState
var events by useState<List<Veranstaltung>>(emptyList())
var loading by useState(true)
var error by useState<String?>(null)
// Data loading with useEffectOnce hook
useEffectOnce {
val scope = MainScope()
scope.launch {
try {
loading = true
error = null
// Load data with Ktor client
val response = apiClient.get("http://localhost:8080/api/events")
val loadedEvents: List<Veranstaltung> = response.body()
events = loadedEvents
} catch (e: Exception) {
error = "Fehler beim Laden der Veranstaltungen: ${e.message}"
console.error("Error loading events:", e)
} finally {
loading = false
}
}
}
// Render HTML with React DOM elements
div {
css {
// Basic styling for the main container
}
h1 {
+"Veranstaltungen"
}
when {
loading -> {
div {
+"Lade Veranstaltungen..."
}
}
error != null -> {
div {
+error!!
}
}
events.isEmpty() -> {
div {
+"Keine Veranstaltungen verfügbar"
}
}
else -> {
div {
events.forEach { event ->
div {
h3 {
+event.name
}
p {
span {
+"📍"
}
+" ${event.ort}"
}
p {
span {
+"📅"
}
if (event.isMultiDay()) {
+" ${event.startDatum} - ${event.endDatum} (${event.getDurationInDays()} Tage)"
} else {
+" ${event.startDatum} (Eintägige Veranstaltung)"
}
}
// Status indicators
val statusList = mutableListOf<String>()
if (event.istAktiv) statusList.add("Aktiv")
if (event.istOeffentlich) statusList.add("Öffentlich")
if (event.isRegistrationOpen()) statusList.add("Anmeldung offen")
if (statusList.isNotEmpty()) {
p {
span {
+"ℹ️"
}
+" Status: ${statusList.joinToString(", ")}"
}
}
// Description
if (!event.beschreibung.isNullOrBlank()) {
p {
span {
+"📝"
}
+" ${event.beschreibung}"
}
}
// Sports/Sparten
if (event.sparten.isNotEmpty()) {
p {
span {
+"🏆"
}
+" Sparten: ${event.sparten.joinToString(", ") { it.name }}"
}
}
// Additional info
event.maxTeilnehmer?.let { max ->
p {
span {
+"👥"
}
+" Max. Teilnehmer: $max"
}
}
event.anmeldeschluss?.let { deadline ->
p {
span {
+"⏰"
}
+" Anmeldeschluss: $deadline"
}
}
}
}
}
}
}
}
}
client/common-ui/src/main/kotlin/at/mocode/client/common/components/horses/PferdeListe.kt.bak
-308
View File
@@ -1,308 +0,0 @@
package at.mocode.client.common.components.horses
import at.mocode.horses.domain.model.DomPferd
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import kotlinx.serialization.json.Json
import react.*
import react.dom.html.ReactHTML.div
import react.dom.html.ReactHTML.h1
import react.dom.html.ReactHTML.h3
import react.dom.html.ReactHTML.p
import react.dom.html.ReactHTML.span
import emotion.react.css
/**
* Props for the PferdeListe component
*/
external interface PferdeListeProps : Props
// Create Ktor client for API calls
private val apiClient = HttpClient {
install(ContentNegotiation) {
json(Json {
ignoreUnknownKeys = true
})
}
}
/**
* React component that displays a list of horses (Pferde).
*
* This component loads horse data from the API and renders it as HTML.
* Uses useState for state management and useEffectOnce for data loading.
*/
val PferdeListe = FC<PferdeListeProps> { _ ->
// State management with useState
var horses by useState<List<DomPferd>>(emptyList())
var loading by useState(true)
var error by useState<String?>(null)
// Data loading with useEffectOnce hook
useEffectOnce {
val scope = MainScope()
scope.launch {
try {
loading = true
error = null
// Load data with Ktor client
val response = apiClient.get("http://localhost:8080/api/horses")
val loadedHorses: List<DomPferd> = response.body()
horses = loadedHorses
} catch (e: Exception) {
error = "Fehler beim Laden der Pferde: ${e.message}"
console.error("Error loading horses:", e)
} finally {
loading = false
}
}
}
// Render HTML with React DOM elements
div {
css {
// Basic styling for the main container
"padding" to "20px"
"fontFamily" to "Arial, sans-serif"
"maxWidth" to "1200px"
"margin" to "0 auto"
}
h1 {
css {
"color" to "#2c3e50"
"borderBottom" to "2px solid #3498db"
"paddingBottom" to "10px"
"marginBottom" to "20px"
}
+"Pferde-Register"
}
when {
loading -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#666"
"fontSize" to "18px"
}
+"Lade Pferde..."
}
}
error != null -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#e74c3c"
"backgroundColor" to "#fdeaea"
"border" to "1px solid #e74c3c"
"borderRadius" to "8px"
"margin" to "20px 0"
}
+error!!
}
}
horses.isEmpty() -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#666"
"backgroundColor" to "#f8f9fa"
"border" to "1px solid #e0e0e0"
"borderRadius" to "8px"
"margin" to "20px 0"
}
+"Keine Pferde verfügbar"
}
}
else -> {
div {
css {
"display" to "grid"
"gridTemplateColumns" to "repeat(auto-fill, minmax(300px, 1fr))"
"gap" to "20px"
}
horses.forEach { horse ->
div {
css {
"border" to "1px solid #e0e0e0"
"borderRadius" to "8px"
"padding" to "15px"
"backgroundColor" to "#f9f9f9"
"boxShadow" to "0 2px 4px rgba(0,0,0,0.1)"
"transition" to "transform 0.2s ease-in-out, box-shadow 0.2s ease-in-out"
"hover" to {
"transform" to "translateY(-5px)"
"boxShadow" to "0 5px 15px rgba(0,0,0,0.1)"
}
}
h3 {
css {
"color" to "#3498db"
"marginTop" to "0"
"marginBottom" to "10px"
"borderBottom" to "1px solid #e0e0e0"
"paddingBottom" to "5px"
}
+horse.getDisplayName()
}
// Basic information
p {
span {
+"🐎"
}
+" Geschlecht: ${horse.geschlecht.name}"
}
horse.geburtsdatum?.let { birthDate ->
p {
span {
+"📅"
}
+" Geburtsdatum: $birthDate"
horse.getAge()?.let { age ->
+" (${age} Jahre alt)"
}
}
}
horse.rasse?.let { breed ->
p {
span {
+"🏇"
}
+" Rasse: $breed"
}
}
horse.farbe?.let { color ->
p {
span {
+"🎨"
}
+" Farbe: $color"
}
}
horse.stockmass?.let { height ->
p {
span {
+"📏"
}
+" Stockmaß: ${height} cm"
}
}
// Identification numbers
val identificationNumbers = mutableListOf<String>()
horse.lebensnummer?.let { identificationNumbers.add("Lebensnummer: $it") }
horse.chipNummer?.let { identificationNumbers.add("Chip: $it") }
horse.passNummer?.let { identificationNumbers.add("Pass: $it") }
horse.oepsNummer?.let { identificationNumbers.add("OEPS: $it") }
horse.feiNummer?.let { identificationNumbers.add("FEI: $it") }
if (identificationNumbers.isNotEmpty()) {
p {
span {
+"🆔"
}
+" Identifikation: ${identificationNumbers.joinToString(", ")}"
}
}
// Pedigree information
val pedigreeInfo = mutableListOf<String>()
horse.vaterName?.let { pedigreeInfo.add("Vater: $it") }
horse.mutterName?.let { pedigreeInfo.add("Mutter: $it") }
horse.mutterVaterName?.let { pedigreeInfo.add("Muttervater: $it") }
if (pedigreeInfo.isNotEmpty()) {
p {
span {
+"🧬"
}
+" Abstammung: ${pedigreeInfo.joinToString(", ")}"
}
}
// Breeding information
horse.zuechterName?.let { breeder ->
p {
span {
+"👨‍🌾"
}
+" Züchter: $breeder"
}
}
horse.zuchtbuchNummer?.let { studbook ->
p {
span {
+"📖"
}
+" Zuchtbuchnummer: $studbook"
}
}
// Status indicators
val statusList = mutableListOf<String>()
if (horse.istAktiv) statusList.add("Aktiv") else statusList.add("Inaktiv")
if (horse.hasCompleteIdentification()) statusList.add("Vollständig identifiziert")
if (horse.isOepsRegistered()) statusList.add("OEPS registriert")
if (horse.isFeiRegistered()) statusList.add("FEI registriert")
p {
span {
+"ℹ️"
}
+" Status: ${statusList.joinToString(", ")}"
}
// Data source
p {
span {
+"📊"
}
+" Datenquelle: ${horse.datenQuelle.name}"
}
// Notes
horse.bemerkungen?.let { notes ->
p {
span {
+"📝"
}
+" Bemerkungen: $notes"
}
}
// Creation and update dates
p {
span {
+"📅"
}
+" Erstellt am: ${horse.createdAt}"
}
p {
span {
+"🔄"
}
+" Zuletzt geändert: ${horse.updatedAt}"
}
}
}
}
}
}
}
}
client/common-ui/src/main/kotlin/at/mocode/client/common/components/masterdata/StammdatenListe.kt.bak
-257
View File
@@ -1,257 +0,0 @@
package at.mocode.client.common.components.masterdata
import at.mocode.masterdata.domain.model.LandDefinition
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch
import kotlinx.serialization.json.Json
import react.*
import react.dom.html.ReactHTML.div
import react.dom.html.ReactHTML.h1
import react.dom.html.ReactHTML.h2
import react.dom.html.ReactHTML.h3
import react.dom.html.ReactHTML.p
import react.dom.html.ReactHTML.span
import emotion.react.css
/**
* Props for the StammdatenListe component
*/
external interface StammdatenListeProps : Props
// Create Ktor client for API calls
private val apiClient = HttpClient {
install(ContentNegotiation) {
json(Json {
ignoreUnknownKeys = true
})
}
}
/**
* React component that displays master data (Stammdaten).
*
* This component loads master data from the API and renders it as HTML.
* Currently focuses on countries (LandDefinition) but can be extended for other master data types.
* Uses useState for state management and useEffectOnce for data loading.
*/
val StammdatenListe = FC<StammdatenListeProps> { _ ->
// State management with useState
var countries by useState<List<LandDefinition>>(emptyList())
var loading by useState(true)
var error by useState<String?>(null)
// Data loading with useEffectOnce hook
useEffectOnce {
val scope = MainScope()
scope.launch {
try {
loading = true
error = null
// Load data with Ktor client
val response = apiClient.get("http://localhost:8080/api/masterdata/countries")
val loadedCountries: List<LandDefinition> = response.body()
countries = loadedCountries
} catch (e: Exception) {
error = "Fehler beim Laden der Stammdaten: ${e.message}"
console.error("Error loading master data:", e)
} finally {
loading = false
}
}
}
// Render HTML with React DOM elements
div {
css {
// Basic styling for the main container
"padding" to "20px"
"fontFamily" to "Arial, sans-serif"
"maxWidth" to "1200px"
"margin" to "0 auto"
}
h1 {
css {
"color" to "#2c3e50"
"borderBottom" to "2px solid #3498db"
"paddingBottom" to "10px"
"marginBottom" to "20px"
}
+"Stammdaten"
}
h2 {
css {
"color" to "#34495e"
"marginTop" to "20px"
"marginBottom" to "15px"
"fontSize" to "1.5em"
}
+"Länder"
}
when {
loading -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#666"
"fontSize" to "18px"
}
+"Lade Stammdaten..."
}
}
error != null -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#e74c3c"
"backgroundColor" to "#fdeaea"
"border" to "1px solid #e74c3c"
"borderRadius" to "8px"
"margin" to "20px 0"
}
+error!!
}
}
countries.isEmpty() -> {
div {
css {
"padding" to "20px"
"textAlign" to "center"
"color" to "#666"
"backgroundColor" to "#f8f9fa"
"border" to "1px solid #e0e0e0"
"borderRadius" to "8px"
"margin" to "20px 0"
}
+"Keine Länder verfügbar"
}
}
else -> {
div {
css {
"display" to "grid"
"gridTemplateColumns" to "repeat(auto-fill, minmax(300px, 1fr))"
"gap" to "20px"
}
countries.forEach { country ->
div {
css {
"border" to "1px solid #e0e0e0"
"borderRadius" to "8px"
"padding" to "15px"
"backgroundColor" to "#f9f9f9"
"boxShadow" to "0 2px 4px rgba(0,0,0,0.1)"
"transition" to "transform 0.2s ease-in-out, box-shadow 0.2s ease-in-out"
"hover" to {
"transform" to "translateY(-5px)"
"boxShadow" to "0 5px 15px rgba(0,0,0,0.1)"
}
}
h3 {
css {
"color" to "#3498db"
"marginTop" to "0"
"marginBottom" to "10px"
"borderBottom" to "1px solid #e0e0e0"
"paddingBottom" to "5px"
}
+country.nameDeutsch
}
// ISO codes
p {
span {
+"🌍"
}
+" ISO-Codes: ${country.isoAlpha2Code} / ${country.isoAlpha3Code}"
country.isoNumerischerCode?.let { numCode ->
+" / $numCode"
}
}
// English name if available
country.nameEnglisch?.let { englishName ->
p {
span {
+"🇬🇧"
}
+" Englischer Name: $englishName"
}
}
// EU/EWR membership
val membershipInfo = mutableListOf<String>()
country.istEuMitglied?.let { isEuMember ->
if (isEuMember) membershipInfo.add("EU-Mitglied")
}
country.istEwrMitglied?.let { isEwrMember ->
if (isEwrMember) membershipInfo.add("EWR-Mitglied")
}
if (membershipInfo.isNotEmpty()) {
p {
span {
+"🇪🇺"
}
+" Mitgliedschaft: ${membershipInfo.joinToString(", ")}"
}
}
// Status
p {
span {
+"ℹ️"
}
+" Status: ${if (country.istAktiv) "Aktiv" else "Inaktiv"}"
}
// Sort order if available
country.sortierReihenfolge?.let { sortOrder ->
p {
span {
+"🔢"
}
+" Sortierreihenfolge: $sortOrder"
}
}
// Coat of arms/flag URL if available
country.wappenUrl?.let { flagUrl ->
p {
span {
+"🏴"
}
+" Wappen/Flagge: $flagUrl"
}
}
// Creation and update dates
p {
span {
+"📅"
}
+" Erstellt am: ${country.createdAt}"
}
p {
span {
+"🔄"
}
+" Zuletzt geändert: ${country.updatedAt}"
}
}
}
}
}
}
}
}
client/common-ui/src/main/kotlin/at/mocode/client/common/di/AppDependencies.kt.bak
-148
View File
@@ -1,148 +0,0 @@
package at.mocode.client.common.di
import at.mocode.members.application.usecase.CreatePersonUseCase
import at.mocode.members.domain.repository.PersonRepository
import at.mocode.members.domain.repository.VereinRepository
import at.mocode.members.domain.service.MasterDataService
import at.mocode.client.web.viewmodel.CreatePersonViewModel
import at.mocode.client.web.viewmodel.PersonListViewModel
/**
* Simple dependency injection container for the application.
* In a real application, you might want to use a proper DI framework like Koin.
*/
object AppDependencies {
// Mock implementations for demonstration
// In a real application, these would be proper implementations
private val mockPersonRepository = object : PersonRepository {
override suspend fun save(person: at.mocode.members.domain.model.DomPerson): at.mocode.members.domain.model.DomPerson {
// Mock implementation - just return the person with an ID
return person.copy(personId = com.benasher44.uuid.uuid4())
}
override suspend fun findById(id: com.benasher44.uuid.Uuid): at.mocode.members.domain.model.DomPerson? {
return null // Mock implementation
}
override suspend fun findByOepsSatzNr(oepsSatzNr: String): at.mocode.members.domain.model.DomPerson? {
return null // Mock implementation
}
override suspend fun findByStammVereinId(vereinId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun findByName(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun findAllActive(limit: Int, offset: Int): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun countActive(): Long {
return 0L // Mock implementation
}
override suspend fun existsByOepsSatzNr(oepsSatzNr: String): Boolean {
return false // Mock implementation - no duplicates for demo
}
override suspend fun delete(id: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation
}
}
private val mockVereinRepository = object : VereinRepository {
override suspend fun findById(id: com.benasher44.uuid.Uuid): at.mocode.members.domain.model.DomVerein? {
return null // Mock implementation
}
override suspend fun findByOepsVereinsNr(oepsVereinsNr: String): at.mocode.members.domain.model.DomVerein? {
return null // Mock implementation
}
override suspend fun findByName(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByBundeslandId(bundeslandId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByLandId(landId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findAllActive(limit: Int, offset: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByLocation(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun save(verein: at.mocode.members.domain.model.DomVerein): at.mocode.members.domain.model.DomVerein {
return verein.copy(vereinId = com.benasher44.uuid.uuid4()) // Mock implementation
}
override suspend fun delete(id: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation
}
override suspend fun existsByOepsVereinsNr(oepsVereinsNr: String): Boolean {
return false // Mock implementation
}
override suspend fun countActive(): Long {
return 0L // Mock implementation
}
override suspend fun countActiveByBundeslandId(bundeslandId: com.benasher44.uuid.Uuid): Long {
return 0L // Mock implementation
}
}
private val mockMasterDataService = object : MasterDataService {
override suspend fun countryExists(countryId: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation - assume all countries exist
}
override suspend fun stateExists(stateId: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation - assume all states exist
}
override suspend fun getCountryById(countryId: com.benasher44.uuid.Uuid): MasterDataService.CountryInfo? {
return null // Mock implementation
}
override suspend fun getStateById(stateId: com.benasher44.uuid.Uuid): MasterDataService.StateInfo? {
return null // Mock implementation
}
override suspend fun getAllCountries(): List<MasterDataService.CountryInfo> {
return emptyList() // Mock implementation
}
override suspend fun getStatesByCountry(countryId: com.benasher44.uuid.Uuid): List<MasterDataService.StateInfo> {
return emptyList() // Mock implementation
}
}
// Use case instances
private val createPersonUseCase = CreatePersonUseCase(
personRepository = mockPersonRepository,
vereinRepository = mockVereinRepository,
masterDataService = mockMasterDataService
)
// ViewModel factory methods
fun createPersonViewModel(): CreatePersonViewModel {
return CreatePersonViewModel(createPersonUseCase)
}
fun personListViewModel(): PersonListViewModel {
return PersonListViewModel(mockPersonRepository)
}
}
client/desktop-app/build.gradle.kts
+1 -1
View File
@@ -1,7 +1,7 @@
plugins {
kotlin("jvm")
kotlin("plugin.spring")
id("org.springframework.boot") version "3.2.3"
id("org.springframework.boot")
id("io.spring.dependency-management") version "1.1.4"
id("org.jetbrains.compose") version "1.7.3"
id("org.jetbrains.kotlin.plugin.compose") version "2.1.21"
client/web-app/build.gradle.kts
+1 -31
View File
@@ -1,7 +1,7 @@
plugins {
kotlin("jvm")
kotlin("plugin.spring")
id("org.springframework.boot") version "3.2.3"
id("org.springframework.boot")
id("io.spring.dependency-management") version "1.1.4"
id("org.jetbrains.compose") version "1.7.3"
id("org.jetbrains.kotlin.plugin.compose") version "2.1.21"
@@ -12,38 +12,8 @@ repositories {
mavenCentral()
}
// Configure tests to exclude failing tests
tasks.withType<Test> {
useJUnitPlatform()
filter {
// Exclude all tests for now
excludeTestsMatching("at.mocode.client.web.*")
}
}
// Configure Kotlin source sets to exclude problematic files
kotlin {
sourceSets {
main {
kotlin {
// Exclude backup directories
exclude("at/mocode/client/web/screens/bak/**")
exclude("at/mocode/client/web/viewmodel/bak/**")
// We're now fixing these files, so don't exclude them
// exclude("at/mocode/client/web/di/AppDependencies.kt")
// exclude("**/screens/CreatePersonScreen.kt")
// exclude("**/screens/PersonListScreen.kt")
// exclude("**/viewmodel/CreatePersonViewModel.kt")
// exclude("**/viewmodel/PersonListViewModel.kt")
}
}
test {
kotlin {
// Exclude all test files for now
exclude("**/*Test.kt")
}
}
}
}
dependencies {
client/web-app/src/main/kotlin/at/mocode/client/web/di/AppDependencies.kt.bak
-148
View File
@@ -1,148 +0,0 @@
package at.mocode.client.web.di
import at.mocode.members.application.usecase.CreatePersonUseCase
import at.mocode.members.domain.repository.PersonRepository
import at.mocode.members.domain.repository.VereinRepository
import at.mocode.members.domain.service.MasterDataService
import at.mocode.client.web.viewmodel.CreatePersonViewModel
import at.mocode.client.web.viewmodel.PersonListViewModel
/**
* Simple dependency injection container for the application.
* In a real application, you might want to use a proper DI framework like Koin.
*/
object AppDependencies {
// Mock implementations for demonstration
// In a real application, these would be proper implementations
private val mockPersonRepository = object : PersonRepository {
override suspend fun save(person: at.mocode.members.domain.model.DomPerson): at.mocode.members.domain.model.DomPerson {
// Mock implementation - just return the person with an ID
return person.copy(personId = com.benasher44.uuid.uuid4())
}
override suspend fun findById(id: com.benasher44.uuid.Uuid): at.mocode.members.domain.model.DomPerson? {
return null // Mock implementation
}
override suspend fun findByOepsSatzNr(oepsSatzNr: String): at.mocode.members.domain.model.DomPerson? {
return null // Mock implementation
}
override suspend fun findByStammVereinId(vereinId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun findByName(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun findAllActive(limit: Int, offset: Int): List<at.mocode.members.domain.model.DomPerson> {
return emptyList() // Mock implementation
}
override suspend fun countActive(): Long {
return 0L // Mock implementation
}
override suspend fun existsByOepsSatzNr(oepsSatzNr: String): Boolean {
return false // Mock implementation - no duplicates for demo
}
override suspend fun delete(id: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation
}
}
private val mockVereinRepository = object : VereinRepository {
override suspend fun findById(id: com.benasher44.uuid.Uuid): at.mocode.members.domain.model.DomVerein? {
return null // Mock implementation
}
override suspend fun findByOepsVereinsNr(oepsVereinsNr: String): at.mocode.members.domain.model.DomVerein? {
return null // Mock implementation
}
override suspend fun findByName(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByBundeslandId(bundeslandId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByLandId(landId: com.benasher44.uuid.Uuid): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findAllActive(limit: Int, offset: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun findByLocation(searchTerm: String, limit: Int): List<at.mocode.members.domain.model.DomVerein> {
return emptyList() // Mock implementation
}
override suspend fun save(verein: at.mocode.members.domain.model.DomVerein): at.mocode.members.domain.model.DomVerein {
return verein.copy(vereinId = com.benasher44.uuid.uuid4()) // Mock implementation
}
override suspend fun delete(id: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation
}
override suspend fun existsByOepsVereinsNr(oepsVereinsNr: String): Boolean {
return false // Mock implementation
}
override suspend fun countActive(): Long {
return 0L // Mock implementation
}
override suspend fun countActiveByBundeslandId(bundeslandId: com.benasher44.uuid.Uuid): Long {
return 0L // Mock implementation
}
}
private val mockMasterDataService = object : MasterDataService {
override suspend fun countryExists(countryId: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation - assume all countries exist
}
override suspend fun stateExists(stateId: com.benasher44.uuid.Uuid): Boolean {
return true // Mock implementation - assume all states exist
}
override suspend fun getCountryById(countryId: com.benasher44.uuid.Uuid): MasterDataService.CountryInfo? {
return null // Mock implementation
}
override suspend fun getStateById(stateId: com.benasher44.uuid.Uuid): MasterDataService.StateInfo? {
return null // Mock implementation
}
override suspend fun getAllCountries(): List<MasterDataService.CountryInfo> {
return emptyList() // Mock implementation
}
override suspend fun getStatesByCountry(countryId: com.benasher44.uuid.Uuid): List<MasterDataService.StateInfo> {
return emptyList() // Mock implementation
}
}
// Use case instances
private val createPersonUseCase = CreatePersonUseCase(
personRepository = mockPersonRepository,
vereinRepository = mockVereinRepository,
masterDataService = mockMasterDataService
)
// ViewModel factory methods
fun createPersonViewModel(): CreatePersonViewModel {
return CreatePersonViewModel(createPersonUseCase)
}
fun personListViewModel(): PersonListViewModel {
return PersonListViewModel(mockPersonRepository)
}
}
client/web-app/src/main/kotlin/at/mocode/client/web/screens/bak/CreatePersonScreen.kt.bak
-319
View File
@@ -1,319 +0,0 @@
package at.mocode.client.web.screens
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.ArrowBack
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import at.mocode.core.domain.model.GeschlechtE
import at.mocode.client.web.viewmodel.CreatePersonViewModel
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CreatePersonScreen(
viewModel: CreatePersonViewModel,
onNavigateBack: () -> Unit
) {
var showGeschlechtDropdown by remember { mutableStateOf(false) }
// Handle success navigation
LaunchedEffect(viewModel.isSuccess) {
if (viewModel.isSuccess) {
onNavigateBack()
}
}
Scaffold(
topBar = {
TopAppBar(
title = { Text("Person erstellen") },
navigationIcon = {
IconButton(onClick = onNavigateBack) {
Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Zurück")
}
}
)
}
) { paddingValues ->
Column(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Error message
viewModel.errorMessage?.let { error ->
Card(
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.errorContainer
)
) {
Text(
text = error,
modifier = Modifier.padding(16.dp),
color = MaterialTheme.colorScheme.onErrorContainer
)
}
}
// Basic Information Section
Text(
text = "Grunddaten",
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.primary
)
OutlinedTextField(
value = viewModel.nachname,
onValueChange = viewModel::updateNachname,
label = { Text("Nachname *") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
OutlinedTextField(
value = viewModel.vorname,
onValueChange = viewModel::updateVorname,
label = { Text("Vorname *") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
OutlinedTextField(
value = viewModel.titel,
onValueChange = viewModel::updateTitel,
label = { Text("Titel") },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
placeholder = { Text("z.B. Dr., Ing.") }
)
OutlinedTextField(
value = viewModel.oepsSatzNr,
onValueChange = viewModel::updateOepsSatzNr,
label = { Text("OEPS Satznummer") },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
placeholder = { Text("6-stellige Nummer") },
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
)
OutlinedTextField(
value = viewModel.geburtsdatum,
onValueChange = viewModel::updateGeburtsdatum,
label = { Text("Geburtsdatum") },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
placeholder = { Text("YYYY-MM-DD") }
)
// Gender Dropdown
ExposedDropdownMenuBox(
expanded = showGeschlechtDropdown,
onExpandedChange = { showGeschlechtDropdown = !showGeschlechtDropdown }
) {
OutlinedTextField(
value = viewModel.geschlecht?.let {
when(it) {
GeschlechtE.M -> "Männlich"
GeschlechtE.W -> "Weiblich"
GeschlechtE.D -> "Divers"
GeschlechtE.UNBEKANNT -> "Unbekannt"
}
} ?: "",
onValueChange = { },
readOnly = true,
label = { Text("Geschlecht") },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = showGeschlechtDropdown) },
modifier = Modifier
.fillMaxWidth()
)
ExposedDropdownMenu(
expanded = showGeschlechtDropdown,
onDismissRequest = { showGeschlechtDropdown = false }
) {
GeschlechtE.entries.forEach { option ->
DropdownMenuItem(
text = {
Text(when(option) {
GeschlechtE.M -> "Männlich"
GeschlechtE.W -> "Weiblich"
GeschlechtE.D -> "Divers"
GeschlechtE.UNBEKANNT -> "Unbekannt"
})
},
onClick = {
viewModel.updateGeschlecht(option)
showGeschlechtDropdown = false
}
)
}
}
}
// Contact Information Section
Text(
text = "Kontaktdaten",
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.primary
)
OutlinedTextField(
value = viewModel.telefon,
onValueChange = viewModel::updateTelefon,
label = { Text("Telefon") },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Phone)
)
OutlinedTextField(
value = viewModel.email,
onValueChange = viewModel::updateEmail,
label = { Text("E-Mail") },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Email)
)
// Address Section
Text(
text = "Adresse",
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.primary
)
OutlinedTextField(
value = viewModel.strasse,
onValueChange = viewModel::updateStrasse,
label = { Text("Straße und Hausnummer") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
OutlinedTextField(
value = viewModel.plz,
onValueChange = viewModel::updatePlz,
label = { Text("PLZ") },
modifier = Modifier.weight(1f),
singleLine = true,
keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number)
)
OutlinedTextField(
value = viewModel.ort,
onValueChange = viewModel::updateOrt,
label = { Text("Ort") },
modifier = Modifier.weight(2f),
singleLine = true
)
}
OutlinedTextField(
value = viewModel.adresszusatz,
onValueChange = viewModel::updateAdresszusatz,
label = { Text("Adresszusatz") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
// Additional Information Section
Text(
text = "Weitere Informationen",
style = MaterialTheme.typography.headlineSmall,
color = MaterialTheme.colorScheme.primary
)
OutlinedTextField(
value = viewModel.feiId,
onValueChange = viewModel::updateFeiId,
label = { Text("FEI ID") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
OutlinedTextField(
value = viewModel.mitgliedsNummer,
onValueChange = viewModel::updateMitgliedsNummer,
label = { Text("Mitgliedsnummer beim Stammverein") },
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
Row(
modifier = Modifier.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically
) {
Checkbox(
checked = viewModel.istGesperrt,
onCheckedChange = viewModel::updateIstGesperrt
)
Spacer(modifier = Modifier.width(8.dp))
Text("Person ist gesperrt")
}
if (viewModel.istGesperrt) {
OutlinedTextField(
value = viewModel.sperrGrund,
onValueChange = viewModel::updateSperrGrund,
label = { Text("Sperrgrund") },
modifier = Modifier.fillMaxWidth(),
maxLines = 3
)
}
OutlinedTextField(
value = viewModel.notizen,
onValueChange = viewModel::updateNotizen,
label = { Text("Interne Notizen") },
modifier = Modifier.fillMaxWidth(),
maxLines = 4
)
// Action Buttons
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
OutlinedButton(
onClick = onNavigateBack,
modifier = Modifier.weight(1f),
enabled = !viewModel.isLoading
) {
Text("Abbrechen")
}
Button(
onClick = {
viewModel.createPerson()
},
modifier = Modifier.weight(1f),
enabled = !viewModel.isLoading
) {
if (viewModel.isLoading) {
CircularProgressIndicator(
modifier = Modifier.size(16.dp),
strokeWidth = 2.dp
)
} else {
Text("Erstellen")
}
}
}
}
}
}
client/web-app/src/main/kotlin/at/mocode/client/web/screens/bak/PersonListScreen.kt.bak
-212
View File
@@ -1,212 +0,0 @@
package at.mocode.client.web.screens
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import at.mocode.members.domain.model.DomPerson
import at.mocode.core.domain.model.GeschlechtE
import at.mocode.core.domain.model.DatenQuelleE
import at.mocode.client.web.viewmodel.PersonListViewModel
import kotlinx.datetime.LocalDate
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun PersonListScreen(
viewModel: PersonListViewModel,
onNavigateToCreatePerson: () -> Unit
) {
Scaffold(
floatingActionButton = {
FloatingActionButton(
onClick = onNavigateToCreatePerson
) {
Icon(Icons.Default.Add, contentDescription = "Person hinzufügen")
}
}
) { paddingValues ->
Column(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
.padding(16.dp)
) {
Text(
text = "Personen",
style = MaterialTheme.typography.headlineMedium,
fontWeight = FontWeight.Bold,
modifier = Modifier.padding(bottom = 16.dp)
)
// Error handling
viewModel.errorMessage?.let { error ->
Card(
modifier = Modifier
.fillMaxWidth()
.padding(bottom = 16.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.errorContainer
)
) {
Row(
modifier = Modifier.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = error,
color = MaterialTheme.colorScheme.onErrorContainer,
modifier = Modifier.weight(1f)
)
TextButton(
onClick = { viewModel.clearError() }
) {
Text("OK")
}
}
}
}
// Loading indicator
if (viewModel.isLoading) {
Box(
modifier = Modifier.fillMaxWidth(),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
if (!viewModel.isLoading && viewModel.persons.isEmpty()) {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally
) {
Icon(
Icons.Default.Person,
contentDescription = null,
modifier = Modifier.size(64.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant
)
Spacer(modifier = Modifier.height(16.dp))
Text(
text = "Keine Personen vorhanden",
style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
} else {
LazyColumn(
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
items(viewModel.persons) { person ->
PersonCard(person = person)
}
}
}
}
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun PersonCard(person: DomPerson) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
) {
Column(
modifier = Modifier.padding(16.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.Top
) {
Column(modifier = Modifier.weight(1f)) {
Text(
text = "${person.titel?.let { "$it " } ?: ""}${person.vorname} ${person.nachname}",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
person.oepsSatzNr?.let { oepsNr ->
Text(
text = "OEPS: $oepsNr",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.primary
)
}
person.geburtsdatum?.let { birthDate ->
Text(
text = "Geboren: $birthDate",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
Surface(
color = when (person.datenQuelle) {
DatenQuelleE.OEPS_ZNS -> MaterialTheme.colorScheme.primaryContainer
DatenQuelleE.MANUELL -> MaterialTheme.colorScheme.secondaryContainer
},
shape = MaterialTheme.shapes.small
) {
Text(
text = when (person.datenQuelle) {
DatenQuelleE.OEPS_ZNS -> "OEPS"
DatenQuelleE.MANUELL -> "Manuell"
},
modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
style = MaterialTheme.typography.labelSmall,
color = when (person.datenQuelle) {
DatenQuelleE.OEPS_ZNS -> MaterialTheme.colorScheme.onPrimaryContainer
DatenQuelleE.MANUELL -> MaterialTheme.colorScheme.onSecondaryContainer
}
)
}
}
Spacer(modifier = Modifier.height(8.dp))
person.email?.let { email ->
Text(
text = "📧 $email",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
person.telefon?.let { phone ->
Text(
text = "📞 $phone",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
if (person.strasse != null && person.plz != null && person.ort != null) {
Text(
text = "📍 ${person.strasse}, ${person.plz} ${person.ort}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
client/web-app/src/main/kotlin/at/mocode/client/web/viewmodel/bak/CreatePersonViewModel.kt.bak
-181
View File
@@ -1,181 +0,0 @@
package at.mocode.client.web.viewmodel
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import at.mocode.core.domain.model.DatenQuelleE
import at.mocode.core.domain.model.GeschlechtE
import at.mocode.members.application.usecase.CreatePersonUseCase
import kotlinx.coroutines.launch
import kotlinx.datetime.LocalDate
class CreatePersonViewModel(
private val createPersonUseCase: CreatePersonUseCase
) : ViewModel() {
// Form state
var nachname by mutableStateOf("")
private set
var vorname by mutableStateOf("")
private set
var titel by mutableStateOf("")
private set
var oepsSatzNr by mutableStateOf("")
private set
var geburtsdatum by mutableStateOf("")
private set
var geschlecht by mutableStateOf<GeschlechtE?>(null)
private set
var telefon by mutableStateOf("")
private set
var email by mutableStateOf("")
private set
var strasse by mutableStateOf("")
private set
var plz by mutableStateOf("")
private set
var ort by mutableStateOf("")
private set
var adresszusatz by mutableStateOf("")
private set
var feiId by mutableStateOf("")
private set
var mitgliedsNummer by mutableStateOf("")
private set
var notizen by mutableStateOf("")
private set
var istGesperrt by mutableStateOf(false)
private set
var sperrGrund by mutableStateOf("")
private set
// UI state
var isLoading by mutableStateOf(false)
private set
var errorMessage by mutableStateOf<String?>(null)
private set
var isSuccess by mutableStateOf(false)
private set
// Update methods
fun updateNachname(value: String) { nachname = value }
fun updateVorname(value: String) { vorname = value }
fun updateTitel(value: String) { titel = value }
fun updateOepsSatzNr(value: String) { oepsSatzNr = value }
fun updateGeburtsdatum(value: String) { geburtsdatum = value }
fun updateGeschlecht(value: GeschlechtE?) { geschlecht = value }
fun updateTelefon(value: String) { telefon = value }
fun updateEmail(value: String) { email = value }
fun updateStrasse(value: String) { strasse = value }
fun updatePlz(value: String) { plz = value }
fun updateOrt(value: String) { ort = value }
fun updateAdresszusatz(value: String) { adresszusatz = value }
fun updateFeiId(value: String) { feiId = value }
fun updateMitgliedsNummer(value: String) { mitgliedsNummer = value }
fun updateNotizen(value: String) { notizen = value }
fun updateIstGesperrt(value: Boolean) { istGesperrt = value }
fun updateSperrGrund(value: String) { sperrGrund = value }
fun clearError() {
errorMessage = null
}
fun createPerson() {
// Basic validation
when {
nachname.isBlank() -> {
errorMessage = "Nachname ist erforderlich"
return
}
vorname.isBlank() -> {
errorMessage = "Vorname ist erforderlich"
return
}
}
viewModelScope.launch {
isLoading = true
errorMessage = null
try {
// Parse birthdate if provided
val parsedGeburtsdatum = if (geburtsdatum.isNotBlank()) {
try {
val parts = geburtsdatum.split("-")
if (parts.size == 3) {
LocalDate(parts[0].toInt(), parts[1].toInt(), parts[2].toInt())
} else {
errorMessage = "Ungültiges Datumsformat. Verwenden Sie YYYY-MM-DD"
isLoading = false
isSuccess = false
return@launch
}
} catch (_: Exception) {
errorMessage = "Ungültiges Datumsformat. Verwenden Sie YYYY-MM-DD"
isLoading = false
isSuccess = false
return@launch
}
} else null
val request = CreatePersonUseCase.CreatePersonRequest(
oepsSatzNr = oepsSatzNr.takeIf { it.isNotBlank() },
nachname = nachname,
vorname = vorname,
titel = titel.takeIf { it.isNotBlank() },
geburtsdatum = parsedGeburtsdatum,
geschlechtE = geschlecht,
telefon = telefon.takeIf { it.isNotBlank() },
email = email.takeIf { it.isNotBlank() },
strasse = strasse.takeIf { it.isNotBlank() },
plz = plz.takeIf { it.isNotBlank() },
ort = ort.takeIf { it.isNotBlank() },
adresszusatzZusatzinfo = adresszusatz.takeIf { it.isNotBlank() },
feiId = feiId.takeIf { it.isNotBlank() },
mitgliedsNummerBeiStammVerein = mitgliedsNummer.takeIf { it.isNotBlank() },
istGesperrt = istGesperrt,
sperrGrund = sperrGrund.takeIf { it.isNotBlank() },
datenQuelle = DatenQuelleE.MANUELL,
notizenIntern = notizen.takeIf { it.isNotBlank() }
)
val response = createPersonUseCase.execute(request)
if (response.success) {
isSuccess = true
} else {
errorMessage = response.error?.message ?: "Unbekannter Fehler beim Erstellen der Person"
}
} catch (e: Exception) {
errorMessage = "Fehler beim Erstellen der Person: ${e.message}"
} finally {
isLoading = false
}
}
}
fun resetForm() {
nachname = ""
vorname = ""
titel = ""
oepsSatzNr = ""
geburtsdatum = ""
geschlecht = null
telefon = ""
email = ""
strasse = ""
plz = ""
ort = ""
adresszusatz = ""
feiId = ""
mitgliedsNummer = ""
notizen = ""
istGesperrt = false
sperrGrund = ""
isLoading = false
errorMessage = null
isSuccess = false
}
}
client/web-app/src/main/kotlin/at/mocode/client/web/viewmodel/bak/PersonListViewModel.kt.bak
-48
View File
@@ -1,48 +0,0 @@
package at.mocode.client.web.viewmodel
import androidx.compose.runtime.*
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import at.mocode.members.domain.model.DomPerson
import at.mocode.members.domain.repository.PersonRepository
import kotlinx.coroutines.launch
class PersonListViewModel(
private val personRepository: PersonRepository
) : ViewModel() {
// UI state
var persons by mutableStateOf<List<DomPerson>>(emptyList())
private set
var isLoading by mutableStateOf(false)
private set
var errorMessage by mutableStateOf<String?>(null)
private set
init {
loadPersons()
}
fun loadPersons() {
viewModelScope.launch {
isLoading = true
errorMessage = null
try {
persons = personRepository.findAllActive(limit = 100, offset = 0)
} catch (e: Exception) {
errorMessage = "Fehler beim Laden der Personen: ${e.message}"
} finally {
isLoading = false
}
}
}
fun clearError() {
errorMessage = null
}
fun refreshPersons() {
loadPersons()
}
}
core/core-domain/src/main/kotlin/at/mocode/core/domain/event/DomainEvent.kt
+9 -7
View File
@@ -1,7 +1,9 @@
package at.mocode.core.domain.event
import java.time.Instant
import java.util.UUID
import com.benasher44.uuid.Uuid
import com.benasher44.uuid.uuid4
import kotlinx.datetime.Clock
import kotlinx.datetime.Instant
/**
* Interface for all domain events in the system.
@@ -11,7 +13,7 @@ interface DomainEvent {
/**
* Unique identifier for this event instance.
*/
val eventId: UUID
val eventId: Uuid
/**
* Timestamp when the event occurred.
@@ -21,7 +23,7 @@ interface DomainEvent {
/**
* Identifier of the aggregate that the event belongs to.
*/
val aggregateId: UUID
val aggregateId: Uuid
/**
* Version of the aggregate after the event was applied.
@@ -34,8 +36,8 @@ interface DomainEvent {
* Provides default implementations for common properties.
*/
abstract class BaseDomainEvent(
override val eventId: UUID = UUID.randomUUID(),
override val timestamp: Instant = Instant.now(),
override val aggregateId: UUID,
override val eventId: Uuid = uuid4(),
override val timestamp: Instant = Clock.System.now(),
override val aggregateId: Uuid,
override val version: Long
) : DomainEvent
gradle.properties
+8 -30
View File
@@ -1,51 +1,29 @@
#Kotlin
# Kotlin Configuration
kotlin.code.style=official
kotlin.daemon.jvmargs=-Xmx3072M -XX:+UseParallelGC -XX:MaxMetaspaceSize=1024M
#Gradle
# Gradle Configuration
org.gradle.jvmargs=-Xmx3072M -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1024M -XX:+HeapDumpOnOutOfMemoryError
org.gradle.parallel=true
org.gradle.caching=true
org.gradle.configureondemand=true
org.gradle.workers.max=8
# Enable dependency verification for secure builds
org.gradle.dependency.verification=lenient
org.gradle.vfs.watch=true
# Enable dependency locking for reproducible builds
# Security and Reproducibility
org.gradle.dependency.verification=lenient
org.gradle.dependency.locking.enabled=true
#Ktor
# Development
io.ktor.development=true
#IDE
# kotlin.build.report.output=build_scan # Deaktiviert für sauberen Build-Process
# IDE Configuration
kotlin.mpp.androidSourceSetLayoutVersion=2
org.jetbrains.kotlin.wasm.check.wasm.binary.format=false
kotlin.native.ignoreDisabledTargets=true
#IntelliJ IDEA
idea.project.settings.delegate.build.run.actions.to.gradle=true
# Optimierungen für Dependency Resolution (können bei Konflikten helfen)
# Abhängigkeits-Locking aktivieren (empfohlen für reproduzierbare Builds und zur Vermeidung unerwarteter transitive Abhängigkeitsänderungen)
# org.gradle.dependency.locking.enabled=true
# Strikte Abhängigkeitsauflösung erzwingen (kann helfen, subtile Konflikte aufzudecken, aber erfordert sorgfältige Konfiguration)
# configurations.all*.resolutionStrategy.failOnVersionConflict()
# configurations.all*.resolutionStrategy.preferProjectModules() # Bevorzuge Subprojekte gegenüber externen Abhängigkeiten gleicher Identität
# Optimierung für große Multi-Modul-Projekte
# Aktiviert die Konfiguration von Projekten parallel, aber verzögert die eigentliche Ausführung von Tasks so lange wie möglich
# org.gradle.configureondemand=true # Bereits aktiviert
# Nutze das File System Watching für schnellere inkrementelle Builds (Gradle 6.5+)
org.gradle.vfs.watch=true
# Configuration cache temporarily disabled due to serialization issues
# Will be re-enabled after fixing the issues
# org.gradle.unsafe.configuration-cache=true
# org.gradle.unsafe.configuration-cache-problems=warn
# org.gradle.unsafe.configuration-cache.max-problems=5
# Build-Reports minimieren für sauberen Build-Process
# Build Reporting
org.gradle.logging.level=lifecycle
kotlin.build.report.single_file=false
kotlin-js-store/yarn.lock
-3299
View File
File diff suppressed because it is too large Load Diff