Skip to content

11. Fallstudie: Der Kotlin-Client der Anwendung RdvMedecins

11.1. Die Aufgabenstellung

Die Anwendung [RdvMedecins] ermöglicht es, Termine in einer Arztpraxis zu vereinbaren. Der [NestJS]-Kurs hat sie als HTML-Anwendung entwickelt, bei der der Server die Seiten erzeugte; die Kurse [Vue.js], [Angular] und [React] entwickelten dafür Web-Clients, und der [Flutter]-Kurs erstellte einen mobilen Client, der DIESELBEN Bildschirme aus den JSON-Daten erzeugt, die der im Kapitel „Der RdvMedecins-Server als Blackbox“ beschriebene Server liefert. Dieses Kapitel beschreibt, wie man einen nativen [Android]-Client in [Kotlin] und [Jetpack Compose] schreibt.

Der Client muss alles bieten, was die anderen boten:

  • ein Anmeldebildschirm, durch ein CAPTCHA geschützt, mit der Möglichkeit, ein Patientenkonto zu erstellen;
  • der Terminkalender eines Arztes für einen bestimmten Tag, mit Terminbuchung (Fenster zur Patientenauswahl) und Stornierung;
  • für den Administrator die Verwaltung von Ärzten und Klienten (Liste, Hinzufügen, Bearbeiten, Löschen);
  • für den Patienten ein persönlicher Bereich (mit den bevorstehenden Terminen, die er stornieren kann) und die Kontoverwaltung;
  • zwei Sprachen: Französisch und Englisch;
  • dieselben Bildschirme wie in den Web-Clients ([/login], [/schedule], [/doctors], [/my-area] ...), die hier zu ROUTEN der Navigation werden.

Eine mobile App bringt eigene Anforderungen mit: ein schmaler Bildschirm (keine Tabellen mit fünf Spalten), eine Tastatur, die den halben Bildschirm verdeckt, eine Zurück-Taste, Bildschirmdrehung und Sprachwechsel, die die Activity betreffen (sie ERSTELLEN sie NEU), ein Passwortmanager und das Fehlen eines Browsers, der das Token-Cookie speichert.

11.2. Installation und Ausführung

Der JSON-Server muss installiert sein und laufen (siehe Kapitel „Der RdvMedecins-Server als Blackbox“). Der CAPTCHA-Testmodus ist nicht erforderlich: Sie können [CAPTCHA_TEST] in der Datei [.env] des Servers leer lassen.

In [Android Studio] öffnet [File / Open] den Ordner [rdvmedecins_kotlin]; [Gradle] lädt die Bibliotheken herunter (beim ersten Mal dauert das einige Minuten). Sobald der Emulator läuft, verbindet ein Befehlsfenster seinen Port 8080 mit dem Port des Rechners:

adb reverse tcp:8080 tcp:8080

dann installiert und startet die Schaltfläche [Run] die Anwendung. Sie können auch alles in einem Befehlsfenster erledigen, das im Ordner [rdvmedecins_kotlin] geöffnet ist:

1
2
3
gradlew installDebug
gradlew installDebug -Pserver=http://10.0.2.2:8080
gradlew installDebug -Pserver=http://192.168.1.20:8080
  • Die erste Zeile kompiliert die Anwendung und installiert sie auf dem verbundenen Gerät (Emulator oder Telefon), das sich mit [adb reverse] unter der Adresse [http://localhost:8080] mit dem Server verbindet;
  • die zweite, für den Emulator, ohne [adb reverse]: Der Emulator sieht den Rechner unter der Adresse [10.0.2.2];
  • die dritte, für ein echtes Telefon, das per WLAN mit demselben Netz wie der Rechner verbunden ist: Man übergibt die Adresse des Rechners in diesem Netz ([ipconfig] unter [Windows]); die Firewall unter [Windows] muss eingehende Verbindungen auf Port 8080 zulassen. Ein per USB angeschlossenes Telefon (mit aktiviertem „USB-Debugging“ in den Entwickleroptionen) kann ebenfalls [adb reverse] verwenden.

Die Demo-Konten sind auf dem Anmeldebildschirm aufgelistet (Passwort = Login).

11.3. Verwendung der App

Die Screenshots in diesem Abschnitt stammen von einem Pixel-8-Emulator (1080 × 2400 Pixel, 412 × 915 dp). Sie wurden automatisch von einem instrumentierten Test ([app/src/androidTest/.../CaseStudyCaptures.kt], siehe Anhänge) erzeugt, der die App wie ein Benutzer bedient.

11.3.1. Der Anmeldebildschirm

Der Anmeldebildschirm; falsches Passwort: Die Meldung erscheint am unteren Bildschirmrand, und ein neues Bild wird angezeigt (jedes Bild wird nur einmal verwendet):

Image

Image

11.3.2. Der Terminkalender aus Sicht des Administrators und der Ärzte

Angemeldet als [admin], gelangen Sie zum Kalender. Wählen Sie einen Arzt und einen Tag (den Tag in einem Kalender) und dann „View schedule“:

Image

Image

Image

„Book“ öffnet das Buchungsfenster, mit einem Navigationspfad über dem Kalender; der Termin wird gespeichert; „Cancel“ verlangt eine Bestätigung:

Image

Image

Image

Ein Arzt ([pelissier]) gelangt direkt zu SEINEM Tageskalender:

Image

11.3.3. Der Patientenbereich

Ein Patient ([martin]) greift auf „My area“ zu. In einem Kalender bucht er einen Termin für sich selbst, ohne einen Patienten auszuwählen:

Image

Image

Image

Sein Termin erscheint unter seinem Namen; die Schaltfläche „Book“ ist nicht mehr verfügbar (nur ein bevorstehender Termin), und eine Meldung erklärt den Grund. Sein Konto zeigt den Termin an. „Manage my account“: Jede Änderung erfordert das aktuelle Passwort; Fehler stammen vom Server:

Image

Image

Image

Das Menü eines Patienten hat keinen Eintrag „Doctors“. Würde er diesen Bildschirm trotzdem öffnen (über einen Link), zeigte die Navigation eine Fehlerseite 403 an (siehe [navigation/Navigation.kt]).

11.3.4. Ärzte und Klienten verwalten

Die Liste der Ärzte; ein falsch ausgefülltes Hinzufügen; ein erfolgreiches Hinzufügen:

Image

Image

Image

Ein Duplikat; ein erfolgreiches Löschen:

Image

Image

11.3.5. Ein Konto erstellen

Geben Sie auf dem Anmeldebildschirm das CAPTCHA ein und tippen Sie dann auf „Create a patient account“. Das Formular wird vom Server abgelehnt; sobald das Konto erstellt ist, kehren Sie zum Anmeldebildschirm zurück, auf dem die Anmeldedaten vorausgefüllt sind:

Image

Image

11.3.6. Auf Französisch, dann auf einem großen Bildschirm

Das Menü FR / EN in der oberen Leiste ändert die Sprache der Anwendung: Die Activity wird neu erstellt, und ALLES wird neu übersetzt, einschließlich Kalender und Datumsangaben. Auf einem breiten Bildschirm (einem Tablet oder einem quer gehaltenen Telefon) bleibt das Menü links angezeigt:

Image

Image

11.3.7. Abgelaufene Sitzung

Läuft das Token ab (oder wird das Cookie gelöscht), liefert die nächste Anfrage ein 401; die Anwendung leitet zum Anmeldebildschirm um. Nach der Anmeldung leitet sie den Benutzer zu dem Bildschirm zurück, den er sehen wollte:

Image

11.4. Architektur des Clients

rdvmedecins_kotlin/
├── settings.gradle.kts, build.gradle.kts    the Gradle project
├── gradle/libs.versions.toml               the versions of the libraries
└── app/
    ├── build.gradle.kts                    the module of the application
    └── src/
        ├── androidTest/                    the test that makes the screenshots
        └── main/
            ├── AndroidManifest.xml
            ├── assets/i18n/                the dictionaries fr.json, en.json
            ├── res/                        icon, name, theme, languages
            └── java/fr/stahe/rdvmedecins/
                ├── RdvMedecinsApplication.kt  the shared objects
                ├── MainActivity.kt         the single activity
                ├── Config.kt               the address of the server
                ├── Formatting.kt           hours and days
                ├── api/                    the API access layer
                ├── state/                  session, messages, cache
                ├── i18n/                   the languages
                ├── navigation/             the screens, their routes, their access rights
                ├── widgets/                the layout and the reusable components
                └── pages/                  the screens

Dies ist die vom [Android]-Leitfaden („Guide to App Architecture“) empfohlene Architektur, wie folgt vereinfacht:

  • eine Datenschicht ([api/]): die einzige Schicht, die [OkHttp], die URL-Objekte und das JSON-Objekt kennt;
  • eine Zustandsschicht ([state/]): Objekte, deren Eigenschaften [Compose]-Zustände sind, die einmal vom [Application]-Objekt erzeugt und allen Bildschirmen bereitgestellt werden ([LocalDependencies]);
  • eine Schnittstellenschicht ([pages/], [widgets/]): [@Composable]-Funktionen, die den Zustand anzeigen und die Aktionen des Benutzers weitergeben.

Die folgende Tabelle vergleicht die HTML-Anwendung aus dem [NestJS]-Kurs, den [Flutter]-Client und diesen Client:

HTML-Anwendung (NestJS)
Flutter-Client
Kotlin-Client
Der Server rendert jede Seite ([res.render])
Widgets rendern die Bildschirme
[@Composable]-Funktionen erzeugen die Bildschirme
[views/layout.hbs] und seine Partial Views
[layout.dart] (eine [ShellRoute])
[AppLayout.kt], um [NavHost]
die Routen des Controllers
[go_router]
[navigation-compose], [@Serializable]-Routen
[JwtAuthGuard], [RolesGuard]
Die Funktion [redirect] des Routers
[Protected] und ein Effect, der die Sitzung beobachtet
das Token-Cookie, vom Browser gespeichert
ein HTTP-Client, der Cookies verwaltet
der [CookieJar] von [OkHttp]
Flash-Meldung in einem Cookie
ein [ChangeNotifier], [Messages]
eine zustandsbehaftete [Compose]-Klasse, [Messages]
Vom Server gelesene Wörterbücher
[Translations] (JSON)
[Translations] (DIESELBEN JSON-Dateien)
Sprache in einem Cookie gespeichert
in [shared_preferences]
durch [Android] ([setApplicationLocales])
bereits gelesene Daten
[Cache] (einige Zeilen)
[Cache] (einige Zeilen, aus [Deferred])
Formular abgelehnt: Der Server lädt die Seite neu
Antwort 400/409, Fehler unter den Feldern
gleich

Alle Dateien des Clients sind unten abgebildet. Sie sind ausführlich kommentiert; ihre Kommentare sind Teil des Kurses.

11.5. Projektkonfiguration

11.5.1. settings.gradle.kts, build.gradle.kts

// =========================================================================
// settings.gradle.kts - die GLOBALE Konfiguration des Gradle-Projekts
// (von Android Studio generiert; nur rootProject.name wurde geändert)
// =========================================================================

// wo Gradle seine PLUGINS findet (das Android-Plugin, das Compose-Plugin ...)
pluginManagement {
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}
plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}
// wo Gradle die BIBLIOTHEKEN findet: google() für AndroidX und Compose,
// mavenCentral() für OkHttp, kotlinx.serialization, AndroidSVG
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

rootProject.name = "rdvmedecins_kotlin"
// ein einziges Modul: die Anwendung, im Ordner app/
include(":app")
// =========================================================================
// build.gradle.kts (root) - deklariert die Gradle-Plugins, die von den
// Modulen des Projekts verwendet werden, ohne sie hier anzuwenden ("apply false"): Sie werden von
// app/build.gradle.kts angewendet.
// =========================================================================
plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.kotlin.compose) apply false
    alias(libs.plugins.kotlin.serialization) apply false
}

Die Dateien der Beispiele (siehe Beispiel 01).

11.5.2. gradle/libs.versions.toml

# =========================================================================
# gradle/libs.versions.toml - der "Version Catalog" des Projekts
# -------------------------------------------------------------------------
# ALLE Versionen der Plugins und der Bibliotheken an einer einzigen Stelle.
# Die Dateien build.gradle.kts verweisen über Namen darauf
# (libs.okhttp, libs.plugins.kotlin.compose ...). Das entspricht dem
# Abschnitt dependencies der pubspec.yaml von Flutter.
# =========================================================================

[versions]
agp = "9.4.1"
kotlin = "2.2.10"
coreKtx = "1.17.0"
lifecycle = "2.9.4"
activityCompose = "1.11.0"
composeBom = "2026.02.01"
appcompat = "1.7.1"
navigation = "2.9.5"
okhttp = "4.12.0"
kotlinxSerializationJson = "1.9.0"
androidsvg = "1.4"
junit = "4.13.2"
junitVersion = "1.3.0"
espressoCore = "3.7.0"
testRunner = "1.7.0"

[libraries]
# von Android Studio generiert (Vorlage "Empty Activity")
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "testRunner" }
# ─── für RdvMedecins hinzugefügt ───
# die grundlegenden Material-Icons (Add, Delete, Search ...)
androidx-compose-material-icons-core = { group = "androidx.compose.material", name = "material-icons-core" }
# der Lebenszyklus der Activity aus Sicht von Compose 
androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
# viewModel() in einer @Composable-Funktion 
androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
# die EIGENE Sprache der Anwendung 
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
# der Router 
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation" }
# der HTTP-Client 
okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
# JSON-(De-)Serialisierung 
kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
# ein SVG-Bild zeichnen (das CAPTCHA)
androidsvg = { group = "com.caverock", name = "androidsvg-aar", version.ref = "androidsvg" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
# erzeugt den (De-)Serialisierungscode der @Serializable-Klassen
kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

Die Bibliotheken der Beispiele, mit Ausnahme von [DataStore]: Die Sprache speichert [Android] selbst, und das Token wird im Cookie-Jar gespeichert.

11.5.3. app/build.gradle.kts

// =========================================================================
// app/build.gradle.kts - die Konfiguration des Moduls "app": der
// Android-Client von RdvMedecins. Von Android Studio erzeugt (Vorlage "Empty
// Activity") und danach ergänzt (mit "added" markierte Zeilen).
// =========================================================================
plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.kotlin.compose)
    // hinzugefügt: das kotlinx.serialization-Plugin (@Serializable-Klassen)
    alias(libs.plugins.kotlin.serialization)
}

android {
    namespace = "fr.stahe.rdvmedecins"
    compileSdk {
        version = release(37)
    }

    defaultConfig {
        applicationId = "fr.stahe.rdvmedecins"
        minSdk = 26
        targetSdk = 37
        versionCode = 1
        versionName = "1.0"
        // added: die Adresse des JSON-Servers, zur Kompilierzeit änderbar:
        //     gradlew installDebug -Pserver=http://192.168.1.20:8080
        val server = providers.gradleProperty("server").getOrElse("http://localhost:8080")
        buildConfigField("String", "SERVER_URL", "\"$server\"")

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            optimization {
                enable = false
            }
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
    buildFeatures {
        compose = true
        // hinzugefügt: die Klasse BuildConfig (BuildConfig.SERVER_URL)
        buildConfig = true
    }
}

dependencies {
    implementation(platform(libs.androidx.compose.bom))
    implementation(libs.androidx.activity.compose)
    implementation(libs.androidx.compose.material3)
    implementation(libs.androidx.compose.ui)
    implementation(libs.androidx.compose.ui.graphics)
    implementation(libs.androidx.compose.ui.tooling.preview)
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.lifecycle.runtime.ktx)
    // für RdvMedecins hinzugefügt
    implementation(libs.androidx.compose.material.icons.core)
    implementation(libs.androidx.lifecycle.runtime.compose)
    implementation(libs.androidx.lifecycle.viewmodel.compose)
    implementation(libs.androidx.appcompat)
    implementation(libs.androidx.navigation.compose)
    implementation(libs.okhttp)
    implementation(libs.kotlinx.serialization.json)
    implementation(libs.androidsvg)
    // die Tests: die Screenshots des Kurses erstellen (Ordner androidTest)
    testImplementation(libs.junit)
    androidTestImplementation(platform(libs.androidx.compose.bom))
    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
    androidTestImplementation(libs.androidx.espresso.core)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.test.runner)
    debugImplementation(libs.androidx.compose.ui.test.manifest)
    debugImplementation(libs.androidx.compose.ui.tooling)
}

Die aus den Beispielen, mit einer anderen Anwendungs-ID ([fr.stahe.rdvmedecins]): Beide Anwendungen können nebeneinander installiert werden. Der Block [buildTypes] beschreibt die PRODUKTIONSVERSION (siehe Kapitel „Bereitstellung“).

11.5.4. AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
     AndroidManifest.xml - der "Personalausweis" der Anwendung
     ===================================================================== -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- Netzwerkzugriff (der JSON-Server) -->
    <uses-permission android:name="android.permission.INTERNET" />

    <!-- android:name: die Application-Klasse (RdvMedecinsApplication.kt).
         usesCleartextTraffic: das "Cleartext"-HTTP des Entwicklungsservers
         (für einen Produktionsserver mit https zu entfernen, siehe Bereitstellung).
         localeConfig: die von der Anwendung angebotenen Sprachen -->
    <application
        android:name=".RdvMedecinsApplication"
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:localeConfig="@xml/locales_config"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.RdvMedecins"
        android:usesCleartextTraffic="true"
        tools:targetApi="33">

        <!-- die einzige Activity. windowSoftInputMode="adjustResize": Die
             Tastatur verkleinert den Bildschirm, statt ihn zu verdecken -->
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:windowSoftInputMode="adjustResize">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <!-- vor Android 13: AppCompat merkt sich die gewählte Sprache -->
        <service
            android:name="androidx.appcompat.app.AppLocalesMetadataHolderService"
            android:enabled="false"
            android:exported="false">
            <meta-data
                android:name="autoStoreLocales"
                android:value="true" />
        </service>
    </application>

</manifest>
  • eine einzige Activity, [MainActivity]: Alle Bildschirme sind [@Composable]-Funktionen;
  • [windowSoftInputMode="adjustResize"]: Erscheint die Tastatur, verkleinert sich der Bildschirm (statt von der Tastatur verdeckt zu werden);
  • [android:localeConfig] und der Service für [AppCompat]: die anwendungsspezifische Sprache (siehe Beispiel 21).

11.5.5. Ressourcen

<?xml version="1.0" encoding="utf-8"?>
<!-- der Name der Anwendung (unter ihrem Icon). Die Texte der Oberfläche
     stehen dagegen in den Wörterbüchern assets/i18n/fr.json und en.json -->
<resources>
    <string name="app_name">RdvMedecins</string>
</resources>
<?xml version="1.0" encoding="utf-8"?>
<resources>
    <!-- das "Android"-Theme, nur während des Starts sichtbar; ein
         AppCompat-Theme, das von AppCompatActivity benötigt wird (siehe MainActivity.kt) -->
    <style name="Theme.RdvMedecins" parent="Theme.AppCompat.DayNight.NoActionBar" />
</resources>
<?xml version="1.0" encoding="utf-8"?>
<!-- =====================================================================
     res/xml/locales_config.xml - die Sprachen der Anwendung (Beispiel 21)
     ............................................................................
     Deklariert in AndroidManifest.xml (android:localeConfig). Seit
     Android 13 kann der Benutzer die Sprache JEDER
     Anwendung auch in den Einstellungen des Smartphones wählen: Einstellungen > System >
     Sprachen > App-Sprachen.
     ===================================================================== -->
<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
    <locale android:name="fr" />
    <locale android:name="en" />
</locale-config>

Die Texte der Anwendung sind dort NICHT enthalten (nur der Name der Anwendung ist vorhanden): Sie stehen in den JSON-Wörterbüchern [assets/i18n/fr.json] und [en.json] sowie in den Wörterbüchern der Clients [Vue.js], [Angular], [React] und [Flutter]. Ein Auszug:

{
  "APP": {
    "TITLE": "RdvMedecins",
    "LOGOUT": "Se déconnecter",
    "MENU_SCHEDULE": "Agenda",
    "MENU_DOCTORS": "Médecins",
    "MENU_PATIENTS": "Clients",
    "MENU_MY_AREA": "Mon espace",
    "LOADING": "Chargement...",
    "LANGUAGE": "Langue",
    "MENU_ACCOUNT": "Mon compte",
    "CONNECTED_AS": "Connecté : {{name}}",
    "RETRY": "Réessayer"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS": "Comptes de démonstration (mot de passe = login) :",
    "DEMO_ADMIN": "rôle ADMIN : rendez-vous + gestion des médecins et des clients",
    "DEMO_DOCTOR": "rôle DOCTOR : prise et annulation de rendez-vous",
    "DEMO_USER": "rôle USER (patients) : réservation pour eux-mêmes, gestion de leur compte",
    "CREATE_ACCOUNT": "Créer un compte client",
    "CREATE_ACCOUNT_HELP": "Pour créer un compte, recopiez d'abord les caractères de l'image."
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Médecin",
    "CHOOSE_DOCTOR": "-- choisir un médecin --",
    "DAY_LABEL": "Jour",
    "VIEW_SCHEDULE": "Voir l'agenda",
    "CHOOSE_DAY": "Choisir le jour"
  },
  "SCHEDULE": {
    "PAGE_TITLE": "Agenda",
    "TITLE_PREFIX": "Agenda du",
    "COLUMN_SLOT": "Créneau",
    "COLUMN_STATUS": "Statut",
    "FREE": "Libre",

11.6. Start der Anwendung

11.6.1. Config.kt

// =========================================================================
// Config.kt - WO liegt der JSON-Server?
// -------------------------------------------------------------------------
// Eine mobile Anwendung hat keinen "Origin": Ihr muss die vollständige Adresse
// des Servers mitgegeben werden (siehe Beispiel 22 und common/Config.kt der Beispiele):
//   - standardmäßig http://localhost:8080, mit dem Befehl
//         adb reverse tcp:8080 tcp:8080
//     der den Port 8080 des Smartphones (oder des Emulators) mit dem des
//     Rechners verbindet;
//   - oder eine andere Adresse, zur Kompilierzeit festgelegt:
//         gradlew installDebug -Pserver=http://10.0.2.2:8080        (Emulator)
//         gradlew installDebug -Pserver=http://192.168.1.20:8080    (Smartphone im WLAN)
// =========================================================================
package fr.stahe.rdvmedecins

object Config {
    val serverUrl: String = BuildConfig.SERVER_URL
}

Die Serveradresse, zur Kompilierungszeit festgelegt (siehe Beispiel 22).

11.6.2. RdvMedecinsApplication.kt

// =========================================================================
// RdvMedecinsApplication.kt - die von der ganzen Anwendung geteilten Objekte
// -------------------------------------------------------------------------
// Android erzeugt beim Start EIN Application-Objekt, vor jeder Activity, und
// behält es, bis die Anwendung endet. Dort bauen wir einmal
// für alle Mal die von allen Bildschirmen geteilten Objekte auf:
//   - den HTTP-Client (und sein Cookie Jar), die API-Zugriffsschicht;
//   - die Sitzung (wer ist angemeldet?), die Meldungen, den Daten-Cache.
// Sie überleben so die Neuerstellung der Activity (Drehung, Wechsel
// der Sprache). Die Bildschirme erhalten sie über LocalDependencies (siehe
// MainActivity.kt): Es ist eine handgeschriebene "Dependency Injection".
// Zwei Mechanismen verbinden diese Objekte miteinander:
//   1. die Antwort 401 auf eine geschützte Anfrage (abgelaufene Sitzung): Der Benutzer
//      wird vergessen und die Meldung vorbereitet; die Navigation, die
//      die Sitzung beobachtet, kehrt dann zum Anmeldebildschirm zurück;
//   2. ein Benutzerwechsel: Die für den vorherigen Benutzer gelesenen Daten
//      sind wertlos geworden, der Cache wird geleert.
// =========================================================================
package fr.stahe.rdvmedecins

import android.app.Application
import androidx.compose.runtime.snapshotFlow
import androidx.compose.runtime.staticCompositionLocalOf
import fr.stahe.rdvmedecins.api.ApiClient
import fr.stahe.rdvmedecins.api.RdvMedecinsApi
import fr.stahe.rdvmedecins.api.createHttpClient
import fr.stahe.rdvmedecins.state.Cache
import fr.stahe.rdvmedecins.state.Messages
import fr.stahe.rdvmedecins.state.Session
import kotlinx.coroutines.MainScope
import kotlinx.coroutines.launch

class RdvMedecinsApplication : Application() {
    // ein Coroutine-Scope, der so lange lebt wie die Anwendung
    val scope = MainScope()
    lateinit var api: RdvMedecinsApi
        private set
    lateinit var session: Session
        private set
    val messages = Messages()
    val cache = Cache(scope)

    override fun onCreate() {
        super.onCreate()
        val client = ApiClient(createHttpClient(this))
        api = RdvMedecinsApi(client)
        session = Session(api)
        // 1. die abgelaufene Sitzung
        client.onSessionExpired = {
            session.forget()
            messages.flash("ERRORS.SESSION_EXPIRED", success = false)
        }
        // 2. der Benutzer wechselt: snapshotFlow macht aus einem Compose-Zustand einen Flow
        scope.launch {
            snapshotFlow { session.user }.collect { cache.clear() }
        }
    }
}

// das Application-Objekt, allen Bildschirmen zur Verfügung gestellt
val LocalDependencies = staticCompositionLocalOf<RdvMedecinsApplication> { error("no dependencies provided") }
  • Zeilen 35–41: gemeinsame Objekte, einmal erzeugt. [lateinit var]: eine Eigenschaft ohne [null], die später initialisiert wird (in [onCreate]); [MainScope()]: ein Coroutine-Scope, der so lange lebt wie die Anwendung;
  • Zeilen 49–51: Die Sitzung ist abgelaufen: Die dem API-Client anvertraute Funktion (der sonst nichts weiß) vergisst den Benutzer und bereitet die Meldung vor;
  • Zeile 55: [snapshotFlow] wandelt einen [Compose]-Zustand in einen [Flow]-Zustand um (siehe Beispiel 19): Jedes Mal, wenn sich der Benutzer ändert, wird der Cache geleert;
  • Zeile 61: das Objekt [Application], allen Bildschirmen über eine [CompositionLocal] bereitgestellt (siehe Beispiel 14): eine von Hand programmierte „Dependency Injection“.

11.6.3. MainActivity.kt

// =========================================================================
// MainActivity.kt - die einzige Activity der Anwendung
// -------------------------------------------------------------------------
// Alle Bildschirme sind @Composable-Funktionen, die vom NavHost
// (siehe navigation/Navigation.kt) in DIESER Activity angezeigt werden. Sie stellt allen
// Bildschirmen bereit (CompositionLocalProvider):
//   - die gemeinsamen Objekte der Anwendung (LocalDependencies);
//   - die Übersetzungen der aktuellen Sprache (LocalTranslations).
// Es ist eine AppCompatActivity: Sie kann die vom Benutzer gewählte Sprache
// anwenden (siehe Beispiel 21), schon vor Android 13.
// =========================================================================
package fr.stahe.rdvmedecins

import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.ui.graphics.Color
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.rememberTranslations
import fr.stahe.rdvmedecins.navigation.Navigation

// die Farben: das Blau der anderen RdvMedecins-Clients (Bootstrap)
private val colors = lightColorScheme(
    primary = Color(0xFF0D6EFD),
    onPrimary = Color.White,
    primaryContainer = Color(0xFFD8E2FF),
    onPrimaryContainer = Color(0xFF001A41),
    secondaryContainer = Color(0xFFDAE2F9),
    onSecondaryContainer = Color(0xFF131C2B),
    surface = Color(0xFFFAF9FD),
)

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        val dependencies = application as RdvMedecinsApplication
        setContent {
            MaterialTheme(colorScheme = colors) {
                CompositionLocalProvider(
                    LocalDependencies provides dependencies,
                    LocalTranslations provides rememberTranslations(),
                ) {
                    Navigation()
                }
            }
        }
    }
}
  • Zeilen 27–34: die Farben des Themes, das Blau, das auch die anderen Clients verwenden;
  • Zeilen 37–48: eine [AppCompatActivity] (die Sprache, siehe Beispiel 21), die allen Bildschirmen gemeinsame Objekte und Übersetzungen bereitstellt und dann die Navigation anzeigt.

11.6.4. Formatting.kt

// =========================================================================
// Formatting.kt - die Anzeige von Uhrzeiten und Tagen
// -------------------------------------------------------------------------
// Der Server sendet ROHDATEN (startHour: 8, startMinute: 0; day:
// "2026-10-05"); die Formatierung, die von der Sprache abhängt, ist Sache
// des Clients (siehe Beispiel 09).
// =========================================================================
package fr.stahe.rdvmedecins

import fr.stahe.rdvmedecins.api.Slot
import fr.stahe.rdvmedecins.api.ScheduleSlot
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
import java.time.format.FormatStyle
import java.util.Locale

// "8:05" statt "8:5"
fun time(h: Int, m: Int) = "$h:${m.toString().padStart(2, '0')}"

// "8:00 - 8:20"
fun timeRange(c: Slot) = "${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}"
fun timeRange(c: ScheduleSlot) = "${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}"

fun today(): String = LocalDate.now().toString() // "yyyy-MM-dd", das Format der API

// true, wenn day ein existierendes Datum im Format yyyy-MM-dd ist ("2026-02-30": nein)
fun isValidDate(day: String): Boolean =
    Regex("^\\d{4}-\\d{2}-\\d{2}$").matches(day) && runCatching { LocalDate.parse(day) }.isSuccess

// "lundi 5 octobre 2026" / "Monday, October 5, 2026"
fun longDate(day: String, language: String): String =
    LocalDate.parse(day).format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(Locale.forLanguageTag(language)))

// der Material-Kalender arbeitet in Millisekunden (UTC)
fun toMillis(day: String): Long = LocalDate.parse(day).atStartOfDay(ZoneOffset.UTC).toInstant().toEpochMilli()
fun fromMillis(ms: Long): String = Instant.ofEpochMilli(ms).atZone(ZoneOffset.UTC).toLocalDate().toString()

Der Server sendet ROHDATEN ([startHour: 8], [day: "2026-10-05"]): Ihre Formatierung, die von der Sprache abhängt, ist Sache des Clients (siehe Beispiel 09).

11.7. Die Zugriffsschicht für die API

11.7.1. api/HttpClient.kt

// =========================================================================
// api/HttpClient.kt - ein HTTP-Client, der COOKIES verwaltet
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 23 (common/HttpClient.kt). Der RdvMedecins-Server
// legt das JWT-Token in einem httpOnly-Cookie ab. Auf einem Smartphone gibt es keinen
// Browser, der es aufbewahrt: Der "Cookie Jar" (CookieJar) des
// OkHttp-Clients speichert es und sendet es bei jeder Anfrage zurück. Die
// Cookies werden auch auf dem Gerät gespeichert (SharedPreferences): Wir bleiben
// angemeldet, wenn wir die Anwendung beenden und neu starten.
// Zwei Cookies sind unterwegs: das Token (rdvmedecins_jwt, Pfad /api) und der
// Pass für die Kontoerstellung (Pfad /api/register).
// =========================================================================
package fr.stahe.rdvmedecins.api

import android.content.Context
import android.content.SharedPreferences
import androidx.core.content.edit
import fr.stahe.rdvmedecins.Config
import okhttp3.Cookie
import okhttp3.CookieJar
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import java.util.concurrent.TimeUnit

class DeviceCookieJar(private val storage: SharedPreferences) : CookieJar {
    // Cookie-Name -> das Cookie
    private val cookies = mutableMapOf<String, Cookie>()

    init {
        // die bei einer früheren Nutzung gemerkten Cookies
        val base = Config.serverUrl.toHttpUrl()
        for (text in storage.getStringSet(KEY, emptySet()).orEmpty()) {
            Cookie.parse(base, text)?.let { cookies[it.name] = it }
        }
    }

    // die Antwort bringt Cookies mit: Wir speichern sie; ein abgelaufenes Cookie (so löscht
    // der Server das Token bei der Abmeldung) wird entfernt
    @Synchronized
    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
        for (c in cookies) {
            if (c.expiresAt < System.currentTimeMillis() || c.value.isEmpty()) {
                this.cookies.remove(c.name)
            } else {
                this.cookies[c.name] = c
            }
        }
        storage.edit { putStringSet(KEY, this@DeviceCookieJar.cookies.values.map { it.toString() }.toSet()) }
    }

    // eine Anfrage geht hinaus: die Cookies, die sie betreffen und nicht abgelaufen sind
    @Synchronized
    override fun loadForRequest(url: HttpUrl): List<Cookie> =
        cookies.values.filter { it.expiresAt >= System.currentTimeMillis() && it.matches(url) }

    companion object {
        private const val KEY = "rdvmedecins.cookies"
    }
}

fun createHttpClient(context: Context): OkHttpClient = OkHttpClient.Builder()
    .cookieJar(DeviceCookieJar(context.getSharedPreferences("rdvmedecins", Context.MODE_PRIVATE)))
    .connectTimeout(10, TimeUnit.SECONDS)
    .readTimeout(10, TimeUnit.SECONDS)
    .build()

Der HTTP-Client aus Beispiel 23 und sein Cookie-Jar. Zwei Cookies sind im Umlauf: das Token ([rdvmedecins_jwt]) und der Zugang zur Kontoerstellung.

11.7.2. api/ApiError.kt

// =========================================================================
// api/ApiError.kt - EINE Klasse für alle Fehler der API
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 24 (common/ApiError.kt). Alle Fehlerantworten
// des Servers haben dieselbe Form:
//   { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Eine Anfrage ohne Antwort (Netzwerk, Server gestoppt) oder eine Antwort, die
// nicht von unserem Server stammt, wird ebenfalls zu einem ApiError.
// =========================================================================
package fr.stahe.rdvmedecins.api

import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.jsonObject

class ApiError(
    val statusCode: Int, // 0: der Server hat nicht geantwortet
    val key: String, // z. B. "ERRORS.LOGIN_TAKEN"
    val params: Map<String, String> = emptyMap(),
    val fields: Map<String, String> = emptyMap(),
) : Exception("$statusCode $key") {

    override fun toString() = "$statusCode $key"

    companion object {
        fun fromResponse(statusCode: Int, body: String): ApiError {
            val json = runCatching { Json.parseToJsonElement(body).jsonObject }.getOrNull()
            val key = (json?.get("key") as? JsonPrimitive)?.content
            if (json == null || key == null) {
                // kein Schlüssel: Der Proxy oder das Netzwerk hat anstelle des Servers geantwortet
                return ApiError(statusCode, if (statusCode >= 500) "ERRORS.SERVER_UNREACHABLE" else "ERRORS.SERVER_ERROR")
            }
            return ApiError(statusCode, key, strings(json["params"]), strings(json["fields"]))
        }

        private fun strings(json: Any?): Map<String, String> =
            (json as? JsonObject)?.mapValues { (_, v) -> (v as? JsonPrimitive)?.content ?: v.toString() } ?: emptyMap()
    }
}

11.7.3. api/ApiClient.kt

// =========================================================================
// api/ApiClient.kt - ALLE Anfragen an die API laufen hier durch
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 24 (common/Api.kt), mit einer Neuerung: der zentralen
// Behandlung der Antwort 401.
//
// Ein 401 kann jederzeit eintreffen: Das Token ist abgelaufen (2 Stunden), das
// Konto wurde gelöscht, der Server wurde mit einem anderen geheimen
// Schlüssel neu gestartet ... Statt diesen Fall in jedem Bildschirm zu behandeln, behandeln wir ihn
// HIER, einmal. Diese Datei kennt aber weder die Navigation noch die
// Meldungen (sie hängt von nichts ab): Sie ruft eine Funktion auf, die ihr beim
// Start übergeben wurde (onSessionExpired, siehe RdvMedecinsApplication.kt)
// und die den Benutzer vergisst; die Navigation, die die Sitzung beobachtet,
// kehrt dann zum Anmeldebildschirm zurück.
//
// Einige Anfragen behandeln ihr 401 selbst (die Anmeldung, GET
// /api/auth/me ...): Sie sind "öffentlich" (siehe RdvMedecinsApi.kt).
// =========================================================================
package fr.stahe.rdvmedecins.api

import fr.stahe.rdvmedecins.Config
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException

class ApiClient(private val client: OkHttpClient) {
    // was zu tun ist, wenn der Server auf eine geschützte Anfrage mit 401 antwortet
    var onSessionExpired: () -> Unit = {}

    // isPublic: true für die Routen, die das 401 selbst behandeln.
    // withContext(Dispatchers.Main.immediate): Die Funktion endet IMMER
    // im Hauptthread, dem Thread des Bildschirms, egal in welchem Thread
    // der Aufrufer läuft (in einer Anwendung ist das ohnehin der Fall: nichts
    // ändert sich; in einem instrumentierten Test kann der Aufrufer woanders sein). Wir
    // können daher bei der Rückkehr unbesorgt navigieren oder den Zustand ändern
    suspend fun request(method: String, url: String, body: JsonElement? = null, isPublic: Boolean = false): JsonElement? =
        withContext(Dispatchers.Main.immediate) { execute(method, url, body, isPublic) }

    private suspend fun execute(method: String, url: String, body: JsonElement?, isPublic: Boolean): JsonElement? {
        val response = withContext(Dispatchers.IO) {
            val httpBody = body?.toString()?.toRequestBody("application/json".toMediaType())
            val request = Request.Builder().url("${Config.serverUrl}/api$url").method(method, httpBody).build()
            try {
                client.newCall(request).execute().use { it.code to it.body?.string().orEmpty() }
            } catch (e: IOException) {
                // keine Antwort: Netzwerk ausgefallen, Server gestoppt, falsche Adresse
                throw ApiError(0, "ERRORS.SERVER_UNREACHABLE")
            }
        }
        // Destrukturierung des Paares (code, text)
        val (code, text) = response
        if (code >= 400) {
            val error = ApiError.fromResponse(code, text)
            if (error.statusCode == 401 && !isPublic) {
                // zurück im Thread des Bildschirms: Wir dürfen den Zustand ändern
                onSessionExpired()
                // der Bildschirm, der auf die Antwort wartete, zeigt AUCH diese Meldung an
                throw ApiError(401, "ERRORS.SESSION_EXPIRED")
            }
            throw error
        }
        return if (text.isEmpty()) null else Json.parseToJsonElement(text)
    }
}
  • Zeilen 42–43: Die Funktion kehrt IMMER im Hauptthread zurück, dem Thread des Bildschirms ([Dispatchers.Main.immediate]): Nach der Rückkehr kann man ohne Vorsichtsmaßnahmen navigieren oder mit dem Zustand interagieren;
  • Zeilen 46–53: die Anfrage im I/O-Thread (siehe Beispiel 24);
  • Zeilen 60–64: die Neuerung: Ein 401 auf einer geschützten Route zeigt eine abgelaufene Sitzung an. Wir behandeln es HIER, einmal für alle Anfragen: [onSessionExpired()], dann ein [ApiError], dessen Schlüssel die anzuzeigende Meldung ist.

11.7.4. api/Types.kt

// =========================================================================
// api/Types.kt - die mit dem Server ausgetauschten JSON-Objekte
// -------------------------------------------------------------------------
// Die Übersetzung der API, die im Kapitel "Der Server, eine Blackbox" beschrieben ist,
// in @Serializable-Klassen von Kotlin (siehe common/Types.kt der
// Beispiele). Das Lesen eines JSON ohne die erwartete Form schlägt
// bereits beim Empfang fehl.
// =========================================================================
package fr.stahe.rdvmedecins.api

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.serializer

enum class Role { ADMIN, DOCTOR, USER }

// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
@Serializable
data class User(val login: String, val name: String, val role: Role)

// GET /api/captcha
@Serializable
data class Captcha(val id: String, val svg: String)

// ein Titel, ein Vorname, ein Nachname
@Serializable
data class Identity(val title: String, val firstName: String, val lastName: String) {
    val label get() = "$title $firstName $lastName" // "Mme Alice DURAND"
}

// ein Arzt oder ein Client: GET /api/doctors, GET /api/clients/:id ...
@Serializable
data class Person(
    val id: Int,
    val version: Int, // optimistisches Sperren: bei einer Aktualisierung zurückzusenden
    val title: String,
    val firstName: String,
    val lastName: String,
    val login: String? = null, // nur für den ADMIN
) {
    val label get() = "$title $firstName $lastName"
}

// ein Zeitfenster
@Serializable
data class Slot(val id: Int, val startHour: Int, val startMinute: Int, val endHour: Int, val endMinute: Int)

// eine Zeile des Terminkalenders mit den RECHTEN des angemeldeten Benutzers
@Serializable
data class ScheduleSlot(
    val id: Int,
    val startHour: Int,
    val startMinute: Int,
    val endHour: Int,
    val endMinute: Int,
    val free: Boolean,
    val patient: Identity?, // null: frei oder von einem anderen Patienten belegt
    val mine: Boolean, // der Termin des angemeldeten Patienten
    val bookable: Boolean,
    val appointmentId: Int?, // gesetzt, wenn der Benutzer stornieren kann
)

// GET /api/schedule?doctorId=...&day=...
@Serializable
data class Schedule(
    val doctor: Person,
    val day: String, // "yyyy-MM-dd"
    val slots: List<ScheduleSlot>,
    val info: String?, // Übersetzungsschlüssel (Patient, der bereits einen Termin hat)
)

// ein Termin aus GET /api/my-area
@Serializable
data class Appointment(val id: Int, val day: String, val slot: Slot, val doctor: Person)

// GET /api/my-area
@Serializable
data class MyArea(val patient: Identity, val appointments: List<Appointment>)

// GET /api/my-account
@Serializable
data class MyAccount(val title: String, val firstName: String, val lastName: String, val login: String, val version: Int)

val apiJson = Json { ignoreUnknownKeys = true }

// JsonElement -> Kotlin-Objekt
inline fun <reified T> JsonElement?.read(): T =
    apiJson.decodeFromJsonElement(serializer<T>(), this ?: throw IllegalStateException("empty response"))

11.7.5. api/RdvMedecinsApi.kt

// =========================================================================
// api/RdvMedecinsApi.kt - eine Funktion pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients (ein "Repository"): Die Bildschirme
// rufen diese typisierten Funktionen auf, ohne etwas von den URLs, von OkHttp oder
// von JSON zu wissen. Ändert sich die API, ändert sich nur diese Datei.
// Jede Funktion ist suspendierend; bei einem Fehler löst sie einen ApiError aus.
// Die Formulardaten sind einfache Map<String, Any?>: Ihre
// Schlüssel sind die Namen der vom Server erwarteten Felder - und die der
// Fehler, die er zurückschickt (ApiError.fields).
// =========================================================================
package fr.stahe.rdvmedecins.api

import android.net.Uri
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.boolean
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive

// /api/doctors oder /api/clients: beide werden gleich behandelt
enum class PersonType(val path: String) { DOCTORS("doctors"), CLIENTS("clients") }

typealias FormData = Map<String, Any?>

// Formulardaten -> ein JSON-Objekt
fun FormData.toJson(): JsonObject = JsonObject(
    mapValues { (_, v) ->
        when (v) {
            null -> JsonNull
            is Number -> JsonPrimitive(v)
            is Boolean -> JsonPrimitive(v)
            else -> JsonPrimitive(v.toString())
        }
    },
)

class RdvMedecinsApi(private val client: ApiClient) {
    private suspend fun get(url: String, isPublic: Boolean = false) = client.request("GET", url, isPublic = isPublic)

    private suspend fun post(url: String, body: JsonElement, isPublic: Boolean = false) =
        client.request("POST", url, body, isPublic)

    // ──────────────────────────────────────────────── Anmeldung (öffentliche Routen)
    suspend fun captcha(): Captcha = get("/captcha", isPublic = true).read()

    suspend fun me(): User = get("/auth/me", isPublic = true).read()

    suspend fun login(login: String, password: String, captchaId: String, captcha: String): User =
        post(
            "/auth/login",
            mapOf("login" to login, "password" to password, "captchaId" to captchaId, "captcha" to captcha).toJson(),
            isPublic = true,
        ).read()

    suspend fun logout() {
        post("/auth/logout", JsonObject(emptyMap()), isPublic = true)
    }

    // ──────────────────────────────────────────────── Kontoerstellung (öffentlich)
    suspend fun registrationAccess(captchaId: String, captcha: String) {
        post("/register/access", mapOf("captchaId" to captchaId, "captcha" to captcha).toJson(), isPublic = true)
    }

    suspend fun registrationAccessStatus(): Boolean =
        get("/register/access", isPublic = true)?.jsonObject?.get("valid")?.jsonPrimitive?.boolean ?: false

    // gibt das Login des erstellten Kontos zurück
    suspend fun register(data: FormData): String =
        post("/register", data.toJson(), isPublic = true)!!.jsonObject["login"]!!.jsonPrimitive.content

    // ──────────────────────────────────────────────── Terminkalender und Termine
    // doctorId null: bei einem angemeldeten Arzt sein EIGENER Terminkalender
    suspend fun schedule(doctorId: Int?, day: String): Schedule {
        val params = Uri.Builder().appendQueryParameter("day", day).apply {
            if (doctorId != null) appendQueryParameter("doctorId", "$doctorId")
        }.build().encodedQuery
        return get("/schedule?$params").read()
    }

    suspend fun book(day: String, slotId: Int, clientId: Int?) {
        post("/appointments", buildMap { put("day", day); put("slotId", slotId); if (clientId != null) put("clientId", clientId) }.toJson())
    }

    suspend fun cancelAppointment(appointmentId: Int) {
        client.request("DELETE", "/appointments/$appointmentId")
    }

    // ──────────────────────────────────────────────── Ärzte und Clients
    suspend fun list(type: PersonType): List<Person> = get("/${type.path}").read()

    suspend fun read(type: PersonType, id: Int): Person = get("/${type.path}/$id").read()

    suspend fun add(type: PersonType, data: FormData): Person = post("/${type.path}", data.toJson()).read()

    suspend fun update(type: PersonType, id: Int, data: FormData): Person =
        client.request("PUT", "/${type.path}/$id", data.toJson()).read()

    suspend fun delete(type: PersonType, id: Int) {
        client.request("DELETE", "/${type.path}/$id")
    }

    // ──────────────────────────────────────────────── der Bereich des Patienten
    suspend fun myArea(): MyArea = get("/my-area").read()

    suspend fun myAccount(): MyAccount = get("/my-account").read()

    suspend fun updateMyAccount(data: FormData): User = client.request("PUT", "/my-account", data.toJson()).read()

    suspend fun deleteMyAccount(currentPassword: String) {
        client.request("DELETE", "/my-account", mapOf("currentPassword" to currentPassword).toJson())
    }
}
  • Zeile 24: Ärzte oder Klienten: eine Aufzählung mit dem Pfad zur API für jeden Eintrag;
  • Zeilen 26–29: Formulardaten: eine [Map], deren Schlüssel die vom Server erwarteten Feldnamen sind, in JSON umgewandelt;
  • Zeilen 40–110: eine Funktion pro Route der API, nach Themen gruppiert; die Routen, die das 401 selbst behandeln, sind „öffentlich“.

11.8. Sprachen

11.8.1. i18n/Translations.kt

// =========================================================================
// i18n/Translations.kt - die Wörterbücher, die aktuelle Sprache
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 25 (Dictionary.kt). Die Wörterbücher
// (assets/i18n/fr.json, en.json) sind die der Clients Vue.js, Angular,
// React und Flutter: dieselben Schlüssel, dieselben Konventionen ({{param}}). Der Server
// sendet nur SCHLÜSSEL zurück ("ERRORS.LOGIN_TAKEN"): Hier werden sie
// zu Text.
//   - t("KEY", mapOf("param" to value)): der Text der aktuellen Sprache;
//   - changeLanguage("fr"): die EIGENE Sprache der Anwendung (siehe Beispiel
//     21), von Android gemerkt; die Activity wird in der neuen
//     Sprache neu erstellt: unsere Texte, aber auch die von Android (der Kalender), die
//     Datumsangaben und die Zahlen.
// =========================================================================
package fr.stahe.rdvmedecins.i18n

import android.content.Context
import androidx.appcompat.app.AppCompatDelegate
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.runtime.staticCompositionLocalOf
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalContext
import androidx.core.os.LocaleListCompat
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive

val languages = listOf("fr", "en")

class Translations(context: Context, val language: String) {
    private val root: JsonObject = context.assets.open("i18n/$language.json").bufferedReader().use {
        Json.parseToJsonElement(it.readText()) as JsonObject
    }

    // "LOGIN.TITLE" -> root["LOGIN"]["TITLE"]; null, wenn nicht vorhanden
    private fun find(key: String): String? {
        var node: JsonElement? = root
        for (part in key.split('.')) node = (node as? JsonObject)?.get(part)
        return (node as? JsonPrimitive)?.takeIf { it.isString }?.content
    }

    // ein unbekannter Schlüssel wird unverändert angezeigt: So sehen wir sofort, was fehlt
    fun t(key: String, params: Map<String, String> = emptyMap()): String {
        val text = find(key) ?: return key
        return Regex("\\{\\{(\\w+)\\}\\}").replace(text) { m -> params[m.groupValues[1]] ?: m.value }
    }
}

// die Sprache der Anwendung: Android merkt sie sich und erstellt die Activity neu
fun changeLanguage(language: String) {
    AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(language))
}

// die Übersetzungen, allen Bildschirmen zur Verfügung gestellt (siehe MainActivity.kt)
val LocalTranslations = staticCompositionLocalOf<Translations> { error("no translations provided") }

// die Übersetzungen der Sprache der aktuellen Konfiguration
@Composable
fun rememberTranslations(): Translations {
    val context = LocalContext.current
    val language = LocalConfiguration.current.locales[0].language.let { if (it in languages) it else "en" }
    return remember(language) { Translations(context, language) }
}

// eine Abkürzung in einer @Composable-Funktion: t("LOGIN.TITLE")
@Composable
fun t(key: String, params: Map<String, String> = emptyMap()): String = LocalTranslations.current.t(key, params)
  • Zeilen 32–45: das Wörterbuch aus Beispiel 25, mit denselben Dateien wie die anderen Clients;
  • Zeilen 57–64: die Übersetzungen für die aktuelle Sprache, allen Bildschirmen bereitgestellt (siehe [MainActivity.kt]); das Wörterbuch wird nur neu gelesen, wenn sich die Sprache ändert;
  • Zeile 69: eine Abkürzung [@Composable], [t("LOGIN.TITLE")]. Wie jede [@Composable]-Funktion kann sie nur innerhalb einer anderen aufgerufen werden: In einem gewöhnlichen Lambda (einem [onClick], dem [text] einer Dropdown-Liste) müssen Sie sie zuvor übersetzen oder [LocalTranslations.current.t(...)] verwenden.

11.9. Der gemeinsame Zustand

11.9.1. state/Session.kt

// =========================================================================
// state/Session.kt - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der angemeldete Benutzer (oder null) in einem von Compose beobachteten Zustand
// (mutableStateOf): Die Bildschirme, die ihn lesen, werden neu zusammengesetzt, wenn er
// sich ändert, und die Navigation (siehe navigation/Navigation.kt) beobachtet ihn, um
// einen nicht mehr erlaubten Bildschirm zu verlassen.
//
// Das JWT-Token selbst liegt NICHT hier: Es liegt in einem Cookie, das vom
// HTTP-Client gespeichert wird. Die Sitzung behält nur die BESCHREIBUNG des Benutzers
// ({ login, name, role }).
//
// Beim Start der Anwendung ist die Sitzung leer: check() fragt
// den Server, nur einmal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================
package fr.stahe.rdvmedecins.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.RdvMedecinsApi
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.User

class Session(private val api: RdvMedecinsApi) {
    var user by mutableStateOf<User?>(null)
        private set

    // true nach einer GEWOLLTEN Abmeldung (Button, Kontolöschung);
    // false nach einer abgelaufenen Sitzung. Die Navigation berücksichtigt das
    var leftVoluntarily = false
        private set

    // der Bildschirm, den wir sehen wollten, als die Sitzung ablief (eine Route):
    // Nach der Anmeldung kehren wir dorthin zurück
    var requestedScreen: Any? = null

    // der angezeigte Bildschirm (eine Route), von jedem geschützten Bildschirm eingetragen
    var currentScreen: Any? = null

    // wurde die Frage "wer ist angemeldet?" bereits gestellt?
    var checked by mutableStateOf(false)
        private set

    // fragt den Server nur beim ersten Mal
    suspend fun check() {
        if (checked) return
        user = try {
            api.me()
        } catch (e: Exception) {
            null // 401: niemand; oder Server nicht erreichbar
        }
        checked = true
    }

    suspend fun login(login: String, password: String, captchaId: String, captcha: String) {
        change(api.login(login, password, captchaId, captcha))
    }

    // der Benutzer hat seinen Namen oder sein Login geändert (PUT /api/my-account)
    fun update(u: User) = change(u)

    suspend fun logout() {
        try {
            api.logout()
        } finally {
            forget(voluntary = true) // auch wenn der Server nicht antwortet
        }
    }

    // ohne den Server etwas zu fragen: abgelaufene Sitzung, gelöschtes Konto
    fun forget(voluntary: Boolean = false) = change(null, voluntary)

    private fun change(u: User?, voluntary: Boolean = false) {
        leftVoluntarily = voluntary
        user = u
    }
}

// was sich aus dem Benutzer ableiten lässt: EXTENSION-Properties des Typs
// User? (sie gelten auch für null)
val User?.isAdmin get() = this?.role == Role.ADMIN
val User?.isPatient get() = this?.role == Role.USER

// ADMIN und DOCTOR: die Termine jedes beliebigen Patienten buchen und stornieren
val User?.isManager get() = this?.role == Role.ADMIN || this?.role == Role.DOCTOR
  • Zeilen 26–27: der Benutzer, ein beobachteter Zustand: Die obere Leiste, das Menü und die Navigation lesen ihn;
  • Zeilen 31–39: was nötig ist, um nach einer abgelaufenen Sitzung zu dem Bildschirm zurückzukehren, den man sehen wollte;
  • Zeilen 82–86: ERWEITERUNGS-Eigenschaften des Typs [User?]: Sie gelten auch für [null] ([this?.role]).

11.9.2. state/Messages.kt

// =========================================================================
// state/Messages.kt - die dem Benutzer angezeigten Meldungen
// -------------------------------------------------------------------------
// Gleiche Darstellung wie bei den anderen RdvMedecins-Clients:
//   - ein ERFOLG wird OBEN auf dem Bildschirm angezeigt (grünes Banner);
//   - ein FEHLER UNTEN (rosa Banner), stets sichtbar.
// Eine Meldung ist ein Übersetzungsschlüssel (+ seine Parameter): Sie wird daher
// von selbst neu übersetzt, wenn der Benutzer die Sprache wechselt.
//
// Die "Flash"-Meldungen: Eine Aktion, die mit einem Bildschirmwechsel endet
// (Buchung, Hinzufügen eines Arztes ...), hinterlässt ihre Meldung mit
// flash(); sie wird auf dem NÄCHSTEN Bildschirm angezeigt und verschwindet bei der
// folgenden Navigation. Die Navigation ruft newPage() bei
// jedem Bildschirmwechsel auf (siehe navigation/Navigation.kt).
// =========================================================================
package fr.stahe.rdvmedecins.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.ApiError

data class Message(val key: String, val params: Map<String, String> = emptyMap())

class Messages {
    var success by mutableStateOf<Message?>(null)
        private set
    var error by mutableStateOf<Message?>(null)
        private set

    // die Meldungen, die auf dem nächsten Bildschirm angezeigt werden
    private var pendingSuccess: Message? = null
    private var pendingError: Message? = null

    fun showSuccess(key: String, params: Map<String, String> = emptyMap()) {
        success = Message(key, params)
        error = null
    }

    fun showError(key: String, params: Map<String, String> = emptyMap()) {
        error = Message(key, params)
        success = null
    }

    fun showApiError(e: ApiError) = showError(e.key, e.params)

    fun clear() {
        success = null
        error = null
    }

    // für den NÄCHSTEN Bildschirm
    fun flash(key: String, params: Map<String, String> = emptyMap(), success: Boolean = true) {
        if (success) pendingSuccess = Message(key, params) else pendingError = Message(key, params)
    }

    // ein neuer Bildschirm: Die Meldungen des vorherigen verschwinden, die
    // Flash-Meldungen erscheinen
    fun newPage() {
        success = pendingSuccess
        error = pendingError
        pendingSuccess = null
        pendingError = null
    }
}

11.9.3. state/Cache.kt

// =========================================================================
// state/Cache.kt - die bereits vom Server gelesenen Daten
// -------------------------------------------------------------------------
// Die Liste der Ärzte ändert sich fast nie: Es ist nicht nötig, sie bei
// jedem Besuch des Terminkalenders neu zu lesen. Der Cache behält das Ergebnis jedes Lesens
// unter einem SCHLÜSSEL ("doctors", "schedule/1/2026-10-05" ...):
//
//     val doctors = cache.read("doctors") { api.list(PersonType.DOCTORS) }
//
// gibt das bereits behaltene Ergebnis zurück oder startet das Lesen und behält
// dessen Ergebnis. Zwei gleichzeitige Anfragen für denselben Schlüssel teilen sich dasselbe
// Lesen (ein Deferred: ein ausstehendes Ergebnis). Ein fehlgeschlagenes Lesen wird nicht
// behalten: Das nächste versucht es erneut.
// Nach einer Aktualisierung werden die betroffenen Schlüssel für UNGÜLTIG erklärt:
// cache.invalidate("schedule"). Die Property version, ein beobachteter Zustand,
// ändert sich dann: Die Bildschirme, die sie lesen (auch wenn sie unter einem Dialog verborgen sind),
// lesen ihre Daten erneut. Es ist, in wenigen Zeilen, was die
// Bibliothek TanStack Query des React-Clients tut.
// =========================================================================
package fr.stahe.rdvmedecins.state

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.setValue
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Deferred
import kotlinx.coroutines.async

class Cache(private val scope: CoroutineScope) {
    private val reads = mutableMapOf<String, Deferred<Any?>>()

    var version by mutableIntStateOf(0)
        private set

    @Suppress("UNCHECKED_CAST")
    suspend fun <T> read(key: String, load: suspend () -> T): T {
        val reading = reads.getOrPut(key) { scope.async { load() } }
        try {
            return reading.await() as T
        } catch (e: Exception) {
            // bei einem Fehler wird dieses Lesen vergessen (die nächste Anfrage versucht es erneut)
            if (reads[key] === reading) reads.remove(key)
            throw e
        }
    }

    // vergisst alle Schlüssel, die mit prefix beginnen, und benachrichtigt die Bildschirme
    fun invalidate(prefix: String) {
        reads.keys.removeAll { it.startsWith(prefix) }
        version++
    }

    // Benutzerwechsel: Alles wird vergessen, OHNE zu benachrichtigen (die Bildschirme
    // des vorherigen Benutzers verschwinden gleich, sie dürfen nichts mehr neu lesen)
    fun clear() = reads.clear()
}
  • Zeilen 36–39: [getOrPut]: Wurde für diesen Schlüssel bereits ein Lesevorgang gestartet, fährt man mit diesem fort; andernfalls startet man einen neuen. [async] startet eine Coroutine, die ein [Deferred] erzeugt, ein noch ausstehendes Ergebnis: Zwei gleichzeitige Anfragen warten ([await]) auf DENSELBEN Lesevorgang;
  • Zeilen 48–50: [invalidate]: Die Bildschirme, die [version] aus dem Schlüssel eines [LaunchedEffect] lesen, lesen ihre Daten neu.

11.10. Navigation

11.10.1. navigation/Screens.kt

// =========================================================================
// navigation/Screens.kt - die ROUTEN der Anwendung (siehe Beispiel 17)
// -------------------------------------------------------------------------
// Dieselben Bildschirme wie bei den anderen Clients (/login, /schedule, /doctors,
// /my-area ...), beschrieben durch @Serializable-Objekte von Kotlin, zusammengefasst
// in einem Objekt Screens: Screens.Schedule(doctorId = 1, day = "2026-10-05").
// DER GESAMTE Zustand eines Bildschirms steckt in seiner Route (der Arzt, der Tag ...): Der
// Zurück-Button des Smartphones stellt ihn unverändert wieder her.
// Der Buchungsdialog ist ebenfalls eine Route (Screens.Booking):
// ein Ziel vom Typ "dialog", das ÜBER dem Terminkalender angezeigt wird; der
// Zurück-Button schließt ihn.
// =========================================================================
package fr.stahe.rdvmedecins.navigation

import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.api.User
import kotlinx.serialization.Serializable

object Screens {
    // der erste Bildschirm: die Zeit, um den Server zu fragen, wer angemeldet ist
    @Serializable
    object Startup

    // login: direkt nach der Erstellung eines Kontos vorausgefüllt
    @Serializable
    data class Login(val login: String = "")

    // day: unverändert, möglicherweise ungültig (der Bildschirm prüft es)
    @Serializable
    data class Schedule(val doctorId: Int? = null, val day: String? = null)

    @Serializable
    data class Booking(val doctorId: Int?, val day: String, val slotId: Int)

    // die Verwaltungsbildschirme der Ärzte ODER der Clients (ADMIN)
    @Serializable
    data class Persons(val type: PersonType)

    // id null: Erstellung; sonst Aktualisierung
    @Serializable
    data class Person(val type: PersonType, val id: Int? = null)

    @Serializable
    object Register

    @Serializable
    object MyArea

    @Serializable
    object MyAccount
}

// die für einen geschützten Bildschirm erlaubten Rollen (null: alle angemeldeten Rollen)
val adminRoles = setOf(Role.ADMIN)
val patientRoles = setOf(Role.USER)

// die Startseite jeder Rolle, direkt nach der Anmeldung
fun home(u: User): Any = if (u.role == Role.USER) Screens.MyArea else Screens.Schedule()

Die Navigationspfade der Anwendung, in einem Objekt [Screens] organisiert. Der GESAMTE Zustand eines Bildschirms ist in seinem Navigationspfad gespeichert; die Zurück-Taste des Telefons stellt ihn exakt so wieder her, wie er war. Das Buchungsfenster ist ebenfalls ein Navigationspfad.

11.10.2. navigation/Navigation.kt

// =========================================================================
// navigation/Navigation.kt - die Bildschirme der Anwendung und ihre Rechte
// -------------------------------------------------------------------------
// Der NavHost (siehe Beispiel 17) zeigt den Bildschirm der aktuellen Route im
// AppLayout an (obere Leiste, Menü, Meldungen).
//
// Die GUARDS (siehe Beispiel 18):
//   - ein geschützter Bildschirm wird von Protected(route, roles) umschlossen: Er wird nur
//     für einen angemeldeten Benutzer mit der richtigen Rolle angezeigt (sonst
//     der Fehlerbildschirm 403);
//   - ein Effekt beobachtet die SITZUNG: Ein Benutzer, der verschwindet (Abmeldung,
//     abgelaufene Sitzung), kehrt zum Anmeldebildschirm zurück; ein Benutzer, der
//     erscheint (Anmeldung), verlässt den Anmeldebildschirm in Richtung des vor
//     dem Ablauf angeforderten Bildschirms, sonst zur Startseite seiner Rolle.
// ZUR ERINNERUNG: Diese Prüfungen sind nur eine ANNEHMLICHKEIT (keinen nutzlosen
// Bildschirm anzeigen). Der Schutz der Daten wird vom Server gewährleistet, der
// das Token und die Rolle bei JEDER Anfrage erneut prüft.
//
// Die "Flash"-Meldungen: bei jedem neuen Bildschirm Messages.newPage().
// =========================================================================
package fr.stahe.rdvmedecins.navigation

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.navigation.NavDestination
import androidx.navigation.NavDestination.Companion.hasRoute
import androidx.navigation.NavHostController
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.dialog
import androidx.navigation.compose.rememberNavController
import androidx.navigation.toRoute
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.pages.SchedulePage
import fr.stahe.rdvmedecins.pages.LoginPage
import fr.stahe.rdvmedecins.pages.StartupPage
import fr.stahe.rdvmedecins.pages.ErrorPage
import fr.stahe.rdvmedecins.pages.PatientAreaPage
import fr.stahe.rdvmedecins.pages.RegisterPage
import fr.stahe.rdvmedecins.pages.MyAccountPage
import fr.stahe.rdvmedecins.pages.PersonFormPage
import fr.stahe.rdvmedecins.pages.PersonsPage
import fr.stahe.rdvmedecins.widgets.BookingDialog
import fr.stahe.rdvmedecins.widgets.AppLayout
import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.map

// die öffentlichen Bildschirme (ohne Anmeldung)
fun isPublic(d: NavDestination) =
    d.hasRoute<Screens.Login>() || d.hasRoute<Screens.Register>() || d.hasRoute<Screens.Startup>()

// zu einem Bildschirm gehen, indem der Stack GELEERT wird: Zurück führt nicht zum vorherigen Bildschirm
fun NavHostController.goTo(route: Any) {
    navigate(route) {
        popUpTo(graph.id) { inclusive = true }
        launchSingleTop = true
    }
}

@Composable
fun Navigation() {
    val nav = rememberNavController()
    val d = LocalDependencies.current
    val session = d.session
    val user = session.user

    // die Flash-Meldungen: bei jedem neuen Bildschirm (ein neuer Eintrag im Stack)
    LaunchedEffect(nav) {
        nav.currentBackStackEntryFlow.map { it.id }.distinctUntilChanged().collect { d.messages.newPage() }
    }

    // die Sitzung ändert sich: bei jedem Benutzerwechsel neu gestartet
    LaunchedEffect(user, session.checked) {
        if (!session.checked) return@LaunchedEffect
        val here = nav.currentBackStackEntry?.destination ?: return@LaunchedEffect
        if (user == null && !isPublic(here)) {
            // abgelaufene Sitzung: Der aktuelle Bildschirm wird gemerkt, um dorthin zurückzukehren
            session.requestedScreen = if (session.leftVoluntarily) null else session.currentScreen
            nav.goTo(Screens.Login())
        } else if (user != null && (here.hasRoute<Screens.Login>() || here.hasRoute<Screens.Startup>())) {
            // angemeldet: Der Anmeldebildschirm ergibt keinen Sinn mehr
            val target = session.requestedScreen ?: home(user)
            session.requestedScreen = null
            nav.goTo(target)
        }
    }

    AppLayout(nav) {
        NavHost(navController = nav, startDestination = Screens.Startup) {
            composable<Screens.Startup> { StartupPage(onNobody = { nav.goTo(Screens.Login()) }) }
            composable<Screens.Login> { e ->
                LoginPage(login = e.toRoute<Screens.Login>().login.take(30), onRegister = { nav.navigate(Screens.Register) })
            }
            composable<Screens.Schedule> { e ->
                val route = e.toRoute<Screens.Schedule>()
                Protected(route) {
                    SchedulePage(
                        doctorId = route.doctorId,
                        day = route.day,
                        // einen anderen Terminkalender ansehen: Die aktuelle Route wird ERSETZT
                        onView = { id, day ->
                            nav.navigate(Screens.Schedule(id, day)) { popUpTo<Screens.Schedule> { inclusive = true } }
                        },
                        // buchen: Der Dialog wird über dem Terminkalender auf den Stack GELEGT
                        onBook = { id, day, slotId -> nav.navigate(Screens.Booking(id, day, slotId)) },
                        onMyArea = { nav.goTo(Screens.MyArea) },
                    )
                }
            }
            dialog<Screens.Booking> { e ->
                val route = e.toRoute<Screens.Booking>()
                Protected(route) { BookingDialog(route, onClose = { nav.popBackStack() }) }
            }
            composable<Screens.Persons> { e ->
                val route = e.toRoute<Screens.Persons>()
                Protected(route, adminRoles) {
                    PersonsPage(
                        type = route.type,
                        onAdd = { nav.navigate(Screens.Person(route.type)) },
                        onEdit = { id -> nav.navigate(Screens.Person(route.type, id)) },
                    )
                }
            }
            composable<Screens.Person> { e ->
                val route = e.toRoute<Screens.Person>()
                Protected(route, adminRoles) {
                    // zurück zur Liste: Das Formular wird vom Stack genommen
                    PersonFormPage(type = route.type, id = route.id, onList = {
                        if (!nav.popBackStack()) nav.goTo(Screens.Persons(route.type))
                    })
                }
            }
            composable<Screens.Register> {
                RegisterPage(onLogin = { login -> nav.goTo(Screens.Login(login)) })
            }
            composable<Screens.MyArea> {
                Protected(Screens.MyArea, patientRoles) {
                    PatientAreaPage(
                        onMyAccount = { nav.navigate(Screens.MyAccount) },
                        onSchedule = { id, day -> nav.navigate(Screens.Schedule(id, day)) },
                    )
                }
            }
            composable<Screens.MyAccount> {
                Protected(Screens.MyAccount, patientRoles) {
                    MyAccountPage(onMyArea = { nav.goTo(Screens.MyArea) })
                }
            }
        }
    }
}

// ein geschützter Bildschirm: angemeldet und, wenn roles nicht null ist, mit einer dieser Rollen
@Composable
fun Protected(route: Any, roles: Set<Role>? = null, content: @Composable () -> Unit) {
    val session = LocalDependencies.current.session
    val u = session.user ?: return // nicht angemeldet: Die Navigation kehrt zur Anmeldung zurück
    // der angezeigte Bildschirm, gemerkt, um nach einer abgelaufenen Sitzung dorthin zurückzukehren
    LaunchedEffect(route) { session.currentScreen = route }
    if (roles != null && u.role !in roles) {
        ErrorPage(code = 403)
    } else {
        content()
    }
}
  • Zeilen 54–57: Zu einem Bildschirm wechseln, indem der Stapel GELEERT wird: Zurück führt nicht zum vorherigen Bildschirm (nach der Anmeldung kehrt man nicht zum Anmeldebildschirm zurück);
  • Zeilen 69–70: Flash-Meldungen: [currentBackStackEntryFlow], ein [Flow] für aufeinanderfolgende Bildschirme;
  • Zeilen 74–85: DER Guard der Anwendung: ein Effect, der jedes Mal ausgelöst wird, wenn sich der Benutzer ändert. Befindet sich niemand auf einem geschützten Bildschirm: bei der Anmeldung (wobei der aktuelle Bildschirm beibehalten wird, wenn die Sitzung abgelaufen ist); befindet sich jemand auf dem Anmeldebildschirm: zum gewünschten Bildschirm, andernfalls zum Startbildschirm seiner Rolle;
  • Zeilen 89–113: der Navigationsgraph im Layout; [dialog<Screens.Booking>]: ein Ziel, das ÜBER dem vorherigen Bildschirm angezeigt wird und das die Zurück-Taste schließt;
  • Zeilen 156–164: [Protected]: nicht angemeldet, nichts (der obige Effect verweist auf die Anmeldung); falsche Rolle, der Fehlerbildschirm 403.

11.11. Wiederverwendbare Komponenten

11.11.1. widgets/AppLayout.kt

// =========================================================================
// widgets/AppLayout.kt - das allen Bildschirmen GEMEINSAME Layout
// -------------------------------------------------------------------------
// Es umschließt den NavHost (siehe navigation/Navigation.kt):
//   - die obere Leiste: Titel, Sprache (FR / EN), Abmeldung;
//   - das seitliche Menü ("Drawer", ModalNavigationDrawer), geöffnet über den
//     Button ☰: die für die Rolle des Benutzers erlaubten Bildschirme. "Doctors" und
//     "Patients" erscheinen nur für den ADMIN: eine reine
//     Anzeigeerleichterung, der eigentliche Schutz liegt beim Server;
//   - eine Erfolgsmeldung OBEN;
//   - der aktuelle Bildschirm (Inhalt);
//   - das Fehlerpanel UNTEN.
// Auf einem großen Bildschirm (Tablet, quer gehaltenes Smartphone) wird das Menü
// dauerhaft links angezeigt: eine NavigationRail anstelle des Drawers.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)

package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.consumeWindowInsets
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ExitToApp
import androidx.compose.material.icons.filled.AccountCircle
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material.icons.filled.Face
import androidx.compose.material.icons.filled.Home
import androidx.compose.material.icons.filled.Menu
import androidx.compose.material.icons.filled.Person
import androidx.compose.material.icons.filled.Warning
import androidx.compose.material3.DrawerValue
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.ListItemDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.ModalDrawerSheet
import androidx.compose.material3.ModalNavigationDrawer
import androidx.compose.material3.NavigationDrawerItem
import androidx.compose.material3.NavigationRail
import androidx.compose.material3.NavigationRailItem
import androidx.compose.material3.Scaffold
import androidx.compose.material3.SuggestionChip
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.material3.VerticalDivider
import androidx.compose.material3.rememberDrawerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.navigation.NavDestination
import androidx.navigation.NavDestination.Companion.hasRoute
import androidx.navigation.NavHostController
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.toRoute
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.api.User
import fr.stahe.rdvmedecins.state.isAdmin
import fr.stahe.rdvmedecins.state.isPatient
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.changeLanguage
import fr.stahe.rdvmedecins.i18n.languages
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.navigation.Screens
import fr.stahe.rdvmedecins.navigation.goTo
import kotlinx.coroutines.launch

// ein Menüeintrag: die Route, zu der er führt, der Schlüssel seiner Beschriftung, sein
// Icon und der Test, der angibt, ob er für einen bestimmten Bildschirm aktiv ist
class MenuEntry(val route: Any, val key: String, val icon: ImageVector, val active: (NavDestination, Any?) -> Boolean)

fun menuEntries(u: User?): List<MenuEntry> {
    if (u == null) return emptyList()
    // buildList: Wir füllen eine Liste mit ifs
    return buildList {
        if (u.isPatient) add(MenuEntry(Screens.MyArea, "APP.MENU_MY_AREA", Icons.Default.Home) { d, _ -> d.hasRoute<Screens.MyArea>() })
        add(MenuEntry(Screens.Schedule(), "APP.MENU_SCHEDULE", Icons.Default.DateRange) { d, _ -> d.hasRoute<Screens.Schedule>() })
        if (u.isAdmin) {
            add(MenuEntry(Screens.Persons(PersonType.DOCTORS), "APP.MENU_DOCTORS", Icons.Default.Face) { _, type -> type == PersonType.DOCTORS })
            add(MenuEntry(Screens.Persons(PersonType.CLIENTS), "APP.MENU_PATIENTS", Icons.Default.Person) { _, type -> type == PersonType.CLIENTS })
        }
        if (u.isPatient) add(MenuEntry(Screens.MyAccount, "APP.MENU_ACCOUNT", Icons.Default.AccountCircle) { d, _ -> d.hasRoute<Screens.MyAccount>() })
    }
}

@Composable
fun AppLayout(nav: NavHostController, content: @Composable () -> Unit) {
    val d = LocalDependencies.current
    val u = d.session.user
    val language = LocalTranslations.current.language
    val scope = rememberCoroutineScope()
    val entries = menuEntries(u)
    // der aktuelle Bildschirm und der Typ der Personen, wenn es eine Liste oder ein Formular ist
    val entry by nav.currentBackStackEntryAsState()
    val destination = entry?.destination
    val type: PersonType? = when {
        destination?.hasRoute<Screens.Persons>() == true -> entry?.toRoute<Screens.Persons>()?.type
        destination?.hasRoute<Screens.Person>() == true -> entry?.toRoute<Screens.Person>()?.type
        else -> null
    }
    fun isActive(e: MenuEntry) = destination != null && e.active(destination, type)
    // ein großer Bildschirm: mindestens 800 dp breit
    val largeScreen = LocalConfiguration.current.screenWidthDp >= 800
    val drawer = rememberDrawerState(DrawerValue.Closed)
    var languageMenu by remember { mutableStateOf(false) }

    val page = @Composable {
        Scaffold(
            topBar = {
                TopAppBar(
                    title = { Text(t("APP.TITLE")) },
                    navigationIcon = {
                        if (u != null && !largeScreen) {
                            IconButton(onClick = { scope.launch { drawer.open() } }) { Icon(Icons.Default.Menu, contentDescription = "menu") }
                        }
                    },
                    colors = TopAppBarDefaults.topAppBarColors(
                        containerColor = MaterialTheme.colorScheme.primary,
                        titleContentColor = MaterialTheme.colorScheme.onPrimary,
                        navigationIconContentColor = MaterialTheme.colorScheme.onPrimary,
                        actionIconContentColor = MaterialTheme.colorScheme.onPrimary,
                    ),
                    actions = {
                        // FR / EN: ein Menü; die Activity wird in der neuen Sprache neu erstellt
                        TextButton(onClick = { languageMenu = true }) {
                            Text(language.uppercase(), color = MaterialTheme.colorScheme.onPrimary, fontWeight = FontWeight.Bold)
                        }
                        DropdownMenu(expanded = languageMenu, onDismissRequest = { languageMenu = false }) {
                            for (l in languages) {
                                DropdownMenuItem(text = { Text(l.uppercase()) }, onClick = {
                                    languageMenu = false
                                    changeLanguage(l)
                                })
                            }
                        }
                        if (u != null) {
                            // die Sitzung wird geleert; die Navigation, die sie beobachtet, zeigt den Anmeldebildschirm an
                            IconButton(onClick = { scope.launch { runCatching { d.session.logout() } } }) {
                                Icon(Icons.AutoMirrored.Filled.ExitToApp, contentDescription = t("APP.LOGOUT"))
                            }
                        }
                    },
                )
            },
        ) { innerPadding ->
            Row(Modifier.padding(innerPadding).consumeWindowInsets(innerPadding).fillMaxSize()) {
                // auf einem großen Bildschirm: das Menü, dauerhaft
                if (u != null && largeScreen) {
                    NavigationRail {
                        for (e in entries) {
                            NavigationRailItem(
                                selected = isActive(e),
                                onClick = { nav.goTo(e.route) },
                                icon = { Icon(e.icon, contentDescription = null) },
                                label = { Text(t(e.key)) },
                            )
                        }
                    }
                    VerticalDivider()
                }
                Column(Modifier.weight(1f).fillMaxSize().imePadding()) {
                    SuccessMessage()
                    Column(Modifier.weight(1f)) { content() }
                    ErrorPanel()
                }
            }
        }
    }

    if (u == null || largeScreen) {
        page()
    } else {
        // der Drawer: nur bei Anmeldung und nur auf einem kleinen Bildschirm
        ModalNavigationDrawer(
            drawerState = drawer,
            drawerContent = {
                ModalDrawerSheet {
                    // der Kopfbereich: wer angemeldet ist
                    Column(Modifier.padding(start = 28.dp, top = 16.dp, end = 16.dp, bottom = 10.dp)) {
                        Text(u.name, style = MaterialTheme.typography.titleMedium)
                        SuggestionChip(onClick = {}, label = { Text(u.role.name) })
                    }
                    for (e in entries) {
                        NavigationDrawerItem(
                            label = { Text(t(e.key)) },
                            icon = { Icon(e.icon, contentDescription = null) },
                            selected = isActive(e),
                            onClick = {
                                scope.launch { drawer.close() }
                                nav.goTo(e.route)
                            },
                            modifier = Modifier.padding(horizontal = 12.dp),
                        )
                    }
                }
            },
        ) { page() }
    }
}

// die Erfolgsmeldung oben
@Composable
private fun SuccessMessage() {
    val messages = LocalDependencies.current.messages
    val success = messages.success ?: return
    ListItem(
        colors = ListItemDefaults.colors(containerColor = Color(0xFFE8F5E9)),
        leadingContent = { Icon(Icons.Default.CheckCircle, contentDescription = null, tint = Color(0xFF2E7D32)) },
        headlineContent = { Text(t(success.key, success.params), color = Color(0xFF1B5E20)) },
        trailingContent = { IconButton(onClick = { messages.clear() }) { Icon(Icons.Default.Close, contentDescription = null) } },
    )
}

// das Fehlerpanel unten: stets sichtbar, auch wenn der Bildschirm scrollt
@Composable
private fun ErrorPanel() {
    val messages = LocalDependencies.current.messages
    val error = messages.error ?: return
    ListItem(
        colors = ListItemDefaults.colors(containerColor = Color(0xFFF8D7DA)),
        leadingContent = { Icon(Icons.Default.Warning, contentDescription = null, tint = Color(0xFFC62828)) },
        headlineContent = { Text(t(error.key, error.params), color = Color(0xFFB71C1C)) },
        trailingContent = { IconButton(onClick = { messages.clear() }) { Icon(Icons.Default.Close, contentDescription = null) } },
    )
}
  • Zeilen 95–97: Menüeinträge je nach Rolle ([buildList]: befüllt eine Liste mit [if]);
  • Zeilen 13–174: ein großer Bildschirm, mindestens 800 dp breit: Das Menü ist eine [NavigationRail], dauerhaft angezeigt; auf einem Telefon im Hochformat eine Schublade ([ModalNavigationDrawer]), die über die Schaltfläche ☰ geöffnet wird;
  • Zeilen 228–241: Meldungen: Erfolg oben, Fehler unten.

11.11.2. widgets/InputField.kt

// =========================================================================
// widgets/InputField.kt - ein vollständiges Formularfeld
// -------------------------------------------------------------------------
// Label + Feld + Hilfemeldung ODER Fehlermeldung. Alle
// Formulare der Anwendung verwenden es:
//
//   InputField(label = "PERSONS.LASTNAME_LABEL", maxLength = 20,
//              value = input["lastName"], onChange = { update("lastName", it) },
//              error = submit.errors["lastName"])
//
// Es ist eine KONTROLLIERTE Komponente (siehe Beispiel 11): Der Wert gehört dem
// übergeordneten Formular. label, help und error sind Übersetzungsschlüssel;
// params, die Parameter ihrer Meldungen ({{min}} ...).
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.semantics.contentType
import androidx.compose.ui.semantics.semantics
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.text.input.VisualTransformation
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t

@Composable
fun InputField(
    label: String,
    value: String,
    onChange: (String) -> Unit,
    error: String? = null,
    help: String? = null,
    params: Map<String, String> = emptyMap(),
    secret: Boolean = false, // ein Passwort: verborgene Zeichen
    maxLength: Int? = null,
    // für den Passwortmanager des Smartphones (Benutzername, Passwort ...)
    autofillType: ContentType? = null,
) {
    val errorMessage = error?.let { t(it, params) }
    val helpMessage = help?.let { t(it, params) }
    OutlinedTextField(
        value = value,
        // das Feld weist überzählige Zeichen zurück
        onValueChange = { v -> if (maxLength == null || v.length <= maxLength) onChange(v) },
        label = { Text(t(label)) },
        singleLine = true,
        isError = errorMessage != null,
        // der Fehler, sonst die Hilfe
        supportingText = (errorMessage ?: helpMessage)?.let { m -> { Text(m) } },
        visualTransformation = if (secret) PasswordVisualTransformation() else VisualTransformation.None,
        keyboardOptions = KeyboardOptions(keyboardType = if (secret) KeyboardType.Password else KeyboardType.Text),
        modifier = Modifier
            .fillMaxWidth()
            .padding(bottom = 4.dp)
            .semantics { if (autofillType != null) contentType = autofillType },
    )
}

11.11.3. widgets/PersonFields.kt

// =========================================================================
// widgets/PersonFields.kt - Titel, Vorname, Nachname
// -------------------------------------------------------------------------
// Die Identitätsfelder, gemeinsam für drei Formulare: das Arzt-/Client-Formular des ADMIN,
// "Create a patient account" und "Manage my account". Das übergeordnete Formular übergibt ihm
// die Werte, die Fehler und die Funktion, die ein Feld aktualisiert:
//     PersonFields(values = input, errors = submit.errors, onChange = ::update)
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t

val titles = listOf("Mr", "Mme", "Melle")

@Composable
fun PersonFields(values: Map<String, Any?>, errors: Map<String, String>, onChange: (String, String) -> Unit) {
    Column {
        DropdownList(
            label = t("PERSONS.TITLE_LABEL"),
            value = values["title"] as String,
            choices = titles,
            onChange = { onChange("title", it) },
            error = errors["title"]?.let { t(it) },
            modifier = Modifier.width(180.dp),
        )
        InputField(
            label = "PERSONS.FIRSTNAME_LABEL",
            maxLength = 20,
            value = values["firstName"] as String,
            onChange = { onChange("firstName", it) },
            error = errors["firstName"],
        )
        InputField(
            label = "PERSONS.LASTNAME_LABEL",
            maxLength = 20,
            value = values["lastName"] as String,
            onChange = { onChange("lastName", it) },
            error = errors["lastName"],
        )
    }
}

11.11.4. widgets/FormSubmit.kt

// =========================================================================
// widgets/FormSubmit.kt - Senden eines Formulars an den Server
// -------------------------------------------------------------------------
// Alle Formulare der Anwendung folgen demselben Muster wie
// Beispiel 25: Auf dem Smartphone wird keine Regel geprüft (sie leben
// an EINER einzigen Stelle, dem Server), und im Fall einer Ablehnung:
//   - wird der Fehler jedes Feldes (ApiError.fields) unter dem Feld angezeigt;
//   - wird die allgemeine Meldung (ApiError.key) am Ende des Bildschirms angezeigt.
// Diese Klasse fasst diese Aktionen zusammen (es ist das Command aus Beispiel 23,
// ergänzt um die Fehler der Felder). Ein Bildschirm erzeugt eines pro Formular:
//
//     val submit = remember { FormSubmit(messages) }
//     if (submit.send { api.register(input) }) { ... }
//     InputField(..., error = submit.errors["lastName"])
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.state.Messages

class FormSubmit(private val messages: Messages) {
    // der Fehler jedes Feldes: ein Übersetzungsschlüssel
    var errors by mutableStateOf(mapOf<String, String>())
        private set

    // die Parameter der Fehlermeldungen ({{min}} ...), vom Server zurückgesendet
    var params by mutableStateOf(mapOf<String, String>())
        private set
    var inProgress by mutableStateOf(false)
        private set

    // führt das Senden aus; gibt true zurück, wenn es erfolgreich war. Bei einem ApiError
    // werden die Fehler angezeigt und false zurückgegeben
    suspend fun send(action: suspend () -> Unit): Boolean {
        if (inProgress) return false // kein doppeltes Absenden
        errors = emptyMap()
        params = emptyMap()
        inProgress = true
        try {
            action()
            return true
        } catch (e: ApiError) {
            messages.showApiError(e)
            errors = e.fields
            params = e.params
            return false
        } finally {
            inProgress = false
        }
    }

    // der Benutzer ändert ein Feld: Sein Fehler verschwindet
    fun clearError(field: String) {
        if (field in errors) errors = errors - field
    }
}

Das [Command] aus Beispiel 23, um Feldfehler ergänzt: Alle Formulare der Anwendung verwenden es.

11.11.5. widgets/Confirmation.kt

// =========================================================================
// widgets/Confirmation.kt - "Are you sure?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 16. Die Meldung ist ein Übersetzungsschlüssel:
//     if (confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) { ... }
// "No, go back" statt "Cancel": Die Frage lautet manchmal "Cancel this
// appointment?", und ein Button "Cancel" wäre dort mehrdeutig.
// Eine neue Frage löscht die Meldungen der vorherigen Aktion.
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.graphics.Color
import fr.stahe.rdvmedecins.state.Messages
import fr.stahe.rdvmedecins.i18n.t
import kotlinx.coroutines.CompletableDeferred

class Confirmation(private val messages: Messages) {
    var question by mutableStateOf<String?>(null)
        private set
    private var pending: CompletableDeferred<Boolean>? = null

    suspend fun confirm(key: String): Boolean {
        messages.clear()
        val waiting = CompletableDeferred<Boolean>()
        pending = waiting
        question = key
        try {
            return waiting.await()
        } finally {
            question = null
        }
    }

    fun answer(yes: Boolean) {
        pending?.complete(yes)
    }
}

@Composable
fun rememberConfirmation(messages: Messages): Confirmation = remember { Confirmation(messages) }

@Composable
fun ConfirmDialog(confirmation: Confirmation) {
    val key = confirmation.question ?: return
    AlertDialog(
        onDismissRequest = { confirmation.answer(false) },
        title = { Text(t("CONFIRMATION.TITLE")) },
        text = { Text(t(key)) },
        dismissButton = { TextButton(onClick = { confirmation.answer(false) }) { Text(t("CONFIRMATION.NO")) } },
        confirmButton = {
            Button(
                onClick = { confirmation.answer(true) },
                colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFC62828)),
            ) { Text(t("CONFIRMATION.YES")) }
        },
    )
}

11.11.6. widgets/CaptchaField.kt

// =========================================================================
// widgets/CaptchaField.kt - das CAPTCHA-Bild und das Eingabefeld
// -------------------------------------------------------------------------
// Eine Anzeigekomponente: das Bild (svg), der Button "Another image"
// (onReload) und das Feld, KONTROLLIERT vom übergeordneten Formular (value,
// onChange). Das Bild und seine Kennung werden vom Anmeldebildschirm beim Server
// angefordert, der sie braucht, um die Antwort zu senden.
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Refresh
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t

@Composable
fun CaptchaField(svg: String?, value: String, onChange: (String) -> Unit, onReload: () -> Unit, error: String? = null) {
    Column {
        Text(t("CAPTCHA.LABEL"), style = MaterialTheme.typography.bodySmall)
        Row(verticalAlignment = Alignment.CenterVertically) {
            Box(
                contentAlignment = Alignment.Center,
                modifier = Modifier
                    .size(160.dp, 54.dp)
                    .background(Color(0xFFF5F7FA), RoundedCornerShape(6.dp))
                    .border(1.dp, Color(0xFFE0E0E0), RoundedCornerShape(6.dp)),
            ) {
                // description: was ein Screenreader anstelle des Bildes vorliest
                if (svg != null) SvgImage(svg, height = 50.dp, description = t("CAPTCHA.IMAGE_ALT"))
            }
            TextButton(onClick = onReload) {
                Icon(Icons.Default.Refresh, contentDescription = null)
                Text(t("CAPTCHA.NEW_IMAGE"))
            }
        }
        InputField(label = "CAPTCHA.LABEL", help = "CAPTCHA.HELP", maxLength = 10, value = value, onChange = onChange, error = error)
    }
}

11.11.7. widgets/SvgImage.kt

// =========================================================================
// widgets/SvgImage.kt (aus den Beispielen übernommen, common/SvgImage.kt) - ein als Text vorliegendes SVG-Bild zeichnen
// -------------------------------------------------------------------------
// Das CAPTCHA-Bild wird vom Server im SVG-Format erzeugt (ein Text,
// der eine Zeichnung beschreibt). Android kann es nicht von allein anzeigen: Die
// Bibliothek AndroidSVG zeichnet es in ein Bild (ein Bitmap), das
// Compose mit der Komponente Image anzeigt.
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import android.graphics.Bitmap
import android.graphics.Canvas
import androidx.compose.foundation.Image
import androidx.compose.foundation.layout.height
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.caverock.androidsvg.SVG

@Composable
fun SvgImage(svg: String, modifier: Modifier = Modifier, height: Dp = 50.dp, description: String? = null) {
    // die Zeichnung wird nur neu erstellt, wenn sich der SVG-Text ändert (remember(svg))
    val image = remember(svg) {
        val document = SVG.getFromString(svg)
        // 3-mal größer als die "natürliche" Größe gezeichnet: ein scharfes Bild
        val scale = 3f
        val docWidth = (document.documentWidth.takeIf { it > 0 } ?: 150f)
        val docHeight = (document.documentHeight.takeIf { it > 0 } ?: 50f)
        val bitmap = Bitmap.createBitmap((docWidth * scale).toInt(), (docHeight * scale).toInt(), Bitmap.Config.ARGB_8888)
        val canvas = Canvas(bitmap)
        canvas.scale(scale, scale)
        document.renderToCanvas(canvas)
        bitmap.asImageBitmap()
    }
    Image(image, contentDescription = description, contentScale = ContentScale.Fit, modifier = modifier.height(height))
}

11.11.8. widgets/DropdownList.kt

// =========================================================================
// widgets/DropdownList.kt (aus den Beispielen übernommen, common/DropdownList.kt) - eine gebrauchsfertige Dropdown-Liste
// -------------------------------------------------------------------------
// Material 3 für Compose hat keine Komponente
// "dropdown list" aus einem Guss: Sie wird aus drei Elementen zusammengesetzt - ExposedDropdownMenuBox,
// einem schreibgeschützten Textfeld und dem Menü ExposedDropdownMenu. Wir
// erledigen das hier ein für alle Mal (Beispiele 05 bis 08, 24, 25):
//
//     DropdownList("Country", value = country, choices = listOf("fr", "be", "ch"),
//                  text = { countryNames[it] }, onChange = { country = it })
//
// Die Funktion ist GENERISCH (<T>): Die Auswahlmöglichkeiten können Strings,
// Zahlen, Ärzte ... sein. text gibt an, wie eine Auswahl ANGEZEIGT wird. Eine Auswahl
// kann null sein ("- choose -"), wenn T ein "nullable" Typ (Int?) ist.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)

package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.ExposedDropdownMenuAnchorType
import androidx.compose.material3.ExposedDropdownMenuBox
import androidx.compose.material3.ExposedDropdownMenuDefaults
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier

@Composable
fun <T> DropdownList(
    label: String,
    value: T,
    choices: List<T>,
    onChange: (T) -> Unit,
    modifier: Modifier = Modifier,
    text: (T) -> String = { it.toString() },
    // eine Fehlermeldung unter dem Feld (siehe Beispiele 07 und 25)
    error: String? = null,
) {
    // ist das Menü geöffnet? ein Zustand, der JEDER Dropdown-Liste EIGEN ist
    var expanded by remember { mutableStateOf(false) }
    ExposedDropdownMenuBox(expanded = expanded, onExpandedChange = { expanded = it }, modifier = modifier) {
        // das Feld, das die aktuelle Auswahl anzeigt; menuAnchor macht es zum
        // Ankerpunkt des Menüs (die Berührung öffnet das Menü)
        OutlinedTextField(
            value = text(value),
            onValueChange = {},
            readOnly = true,
            singleLine = true,
            label = { Text(label) },
            trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
            isError = error != null,
            supportingText = if (error == null) null else { { Text(error) } },
            modifier = Modifier.menuAnchor(ExposedDropdownMenuAnchorType.PrimaryNotEditable).fillMaxWidth(),
        )
        // das Menü: eine Zeile pro Auswahl
        ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
            for (c in choices) {
                DropdownMenuItem(
                    text = { Text(text(c)) },
                    onClick = {
                        onChange(c)
                        expanded = false
                    },
                )
            }
        }
    }
}

11.11.9. widgets/Tag.kt

// widgets/Tag.kt - ein farbiges Tag (das "Badge" der anderen Clients)
package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp

@Composable
fun Tag(text: String, color: Color) {
    Text(
        text,
        color = Color.White,
        fontSize = 12.sp,
        fontWeight = FontWeight.Bold,
        modifier = Modifier.background(color, RoundedCornerShape(6.dp)).padding(horizontal = 8.dp, vertical = 3.dp),
    )
}

11.11.10. widgets/BookingDialog.kt

// =========================================================================
// widgets/BookingDialog.kt - der Buchungsdialog eines Zeitfensters
// -------------------------------------------------------------------------
// Ein Ziel vom Typ "dialog" der Navigation (Screens.Booking):
// Es wird ÜBER dem Terminkalender angezeigt, einschließlich ausgegrautem Hintergrund, und der Zurück-Button
// des Smartphones schließt es. Seine Route enthält alles, was es braucht:
// den Arzt, den Tag, das Zeitfenster.
// Es liest den Terminkalender erneut aus dem CACHE (keine Anfrage: Der Terminkalender wurde
// gerade erst gelesen), um das Zeitfenster darin zu finden und zu prüfen, dass es buchbar ist.
// Nach der Buchung: eine Flash-Meldung, das Schließen und die Ungültigerklärung
// des Caches; der Terminkalender, der unter dem Dialog noch lebt, liest sich erneut.
// =========================================================================
package fr.stahe.rdvmedecins.widgets

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ScheduleSlot
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.state.isManager
import fr.stahe.rdvmedecins.state.isPatient
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.navigation.Screens
import fr.stahe.rdvmedecins.pages.scheduleKey
import kotlinx.coroutines.launch

@Composable
fun BookingDialog(route: Screens.Booking, onClose: () -> Unit) {
    val d = LocalDependencies.current
    val u = d.session.user
    var slot by remember { mutableStateOf<ScheduleSlot?>(null) }
    // ADMIN / DOCTOR: die Patienten zur Auswahl
    var clients by remember { mutableStateOf(listOf<Person>()) }
    var clientId by remember { mutableStateOf<Int?>(null) }
    var sending by remember { mutableStateOf(false) }
    val scope = rememberCoroutineScope()

    LaunchedEffect(Unit) {
        try {
            val schedule = d.cache.read(scheduleKey(route.doctorId, route.day)) { d.api.schedule(route.doctorId, route.day) }
            // nur wenn dieses Zeitfenster von diesem Benutzer buchbar ist
            slot = schedule.slots.find { it.id == route.slotId && it.bookable }
            if (slot == null) onClose()
            if (u.isManager) clients = d.cache.read("clients") { d.api.list(PersonType.CLIENTS) }
        } catch (e: ApiError) {
            d.messages.showApiError(e)
        }
    }

    fun confirm() {
        val c = slot ?: return
        scope.launch {
            sending = true
            try {
                d.api.book(route.day, c.id, if (u.isManager) clientId else null)
                d.messages.flash("SCHEDULE.BOOKED")
            } catch (e: ApiError) {
                if (e.key == "ERRORS.CHOOSE_PATIENT") {
                    // kein Patient gewählt: Der Dialog bleibt geöffnet
                    d.messages.showError(e.key)
                    sending = false
                    return@launch
                }
                // Zeitfenster zwischenzeitlich belegt, Patient, der bereits einen Termin hat ...:
                // Die Meldung wird auf dem Terminkalender angezeigt, Dialog geschlossen
                d.messages.flash(e.key, e.params, success = false)
            }
            sending = false
            onClose()
            // der Server ist die Referenz: Der Terminkalender (und der Patientenbereich) werden erneut gelesen
            d.cache.invalidate("my-area")
            d.cache.invalidate("schedule")
        }
    }

    val c = slot ?: return
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(20.dp)) {
            Text(t("BOOKING_DIALOG.TITLE"), style = MaterialTheme.typography.titleLarge)
            Spacer(Modifier.height(12.dp))
            Text(t("BOOKING_DIALOG.SLOT", mapOf("time" to timeRange(c))))
            Spacer(Modifier.height(12.dp))
            if (u.isPatient) {
                // ein Patient bucht für sich selbst: keine Liste (und der Server
                // würde eine eventuelle clientId ohnehin ignorieren)
                Text(
                    buildAnnotatedString {
                        append("${t("BOOKING_DIALOG.PATIENT_LABEL")}: ")
                        withStyle(SpanStyle(fontWeight = FontWeight.Bold)) { append(u?.name ?: "") }
                    },
                )
            } else {
                val prompt = t("BOOKING_DIALOG.CHOOSE_PATIENT")
                DropdownList(
                    label = t("BOOKING_DIALOG.PATIENT_LABEL"),
                    value = clientId,
                    choices = listOf<Int?>(null) + clients.map { it.id },
                    text = { i -> clients.find { it.id == i }?.label ?: prompt },
                    onChange = { clientId = it },
                    modifier = Modifier.fillMaxWidth(),
                )
            }
            // ein Fehler (kein Patient gewählt): Das Fehlerpanel des Bildschirms ist
            // unter dem Dialog verborgen, wir wiederholen ihn hier
            d.messages.error?.let { m ->
                Text(t(m.key, m.params), color = androidx.compose.ui.graphics.Color(0xFFC62828), modifier = Modifier.padding(top = 8.dp))
            }
            Spacer(Modifier.height(20.dp))
            Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp, androidx.compose.ui.Alignment.End)) {
                TextButton(onClick = onClose) { Text(t("BOOKING_DIALOG.CANCEL")) }
                Button(onClick = { confirm() }, enabled = !sending) { Text(t("BOOKING_DIALOG.CONFIRM")) }
            }
        }
    }
}
  • Zeilen 64–70: der Terminkalender, im CACHE neu gelesen (keine Abfrage: Er wurde gerade gelesen), um das Zeitfenster zu finden; die Patienten, für einen Administrator;
  • Zeilen 76–98: die Reservierung: eine Pop-up-Meldung, das Schließen des Fensters und das Invalidieren des Caches; der Terminkalender, der unter dem Fenster aktiv bleibt, lädt automatisch neu.

11.12. Die Bildschirme

11.12.1. pages/StartupPage.kt

// =========================================================================
// pages/StartupPage.kt - der erste Bildschirm
// -------------------------------------------------------------------------
// Die Zeit, um den Server einmal zu fragen, wer angemeldet ist (GET
// /api/auth/me: Das Token-Cookie kann von einer früheren
// Nutzung behalten worden sein). Angemeldet: Die Navigation (die die Sitzung beobachtet) führt zur
// Startseite der Rolle; niemand: onNobody, der Anmeldebildschirm.
// =========================================================================
package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import fr.stahe.rdvmedecins.LocalDependencies

@Composable
fun StartupPage(onNobody: () -> Unit) {
    val session = LocalDependencies.current.session
    LaunchedEffect(Unit) {
        session.check()
        if (session.user == null) onNobody()
    }
    Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
}

11.12.2. pages/ErrorPage.kt

// =========================================================================
// pages/ErrorPage.kt - der Fehlerbildschirm: 403 (unzureichende Rolle, siehe
// navigation/Navigation.kt) oder 404
// =========================================================================
package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.i18n.t

@Composable
fun ErrorPage(code: Int) {
    Column(Modifier.padding(24.dp)) {
        Text("${t("ERROR_PAGE.TITLE")} $code", style = MaterialTheme.typography.headlineMedium, color = Color(0xFFC62828))
        Spacer(Modifier.height(8.dp))
        Text(t(if (code == 403) "ERRORS.FORBIDDEN" else "ERRORS.NOT_FOUND"))
    }
}

11.12.3. pages/LoginPage.kt

// =========================================================================
// pages/LoginPage.kt - der Anmeldebildschirm
// -------------------------------------------------------------------------
// Derselbe Bildschirm wie bei den anderen Clients: Login, Passwort, CAPTCHA und
// ein zweiter Button "Create a patient account", der dasselbe CAPTCHA prüft, bevor
// die Kontoerstellung geöffnet wird.
// login: Das Feld ist vorausgefüllt (direkt nach der Erstellung eines Kontos).
// Nach einer erfolgreichen Anmeldung navigiert dieser Bildschirm NICHT selbst: Die
// Sitzung ändert sich, und die Navigation verlässt den Anmeldebildschirm
// (siehe navigation/Navigation.kt).
// =========================================================================
package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.SpanStyle
import androidx.compose.ui.text.buildAnnotatedString
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Captcha
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.CaptchaField
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch

@Composable
fun LoginPage(login: String, onRegister: () -> Unit) {
    val d = LocalDependencies.current
    val submit = remember { FormSubmit(d.messages) }
    // die Eingabe: eine Map, Feld -> Wert; rememberSaveable: Sie überlebt einen
    // Sprachwechsel (die Activity wird neu erstellt)
    var input by rememberSaveable { mutableStateOf(mapOf("login" to login, "password" to "", "captcha" to "")) }
    var captcha by remember { mutableStateOf<Captcha?>(null) }
    val scope = rememberCoroutineScope()

    // ein neues Bild: Es wird nach JEDEM Versuch gebraucht, weil ein Bild nur
    // EINMAL verwendet werden kann (der Server vergisst es, sobald er es geprüft hat)
    suspend fun reloadCaptcha() {
        captcha = try {
            d.api.captcha()
        } catch (e: Exception) {
            null // Server nicht erreichbar: Die Anmeldung schlägt mit einer klaren Meldung fehl
        }
    }
    LaunchedEffect(Unit) { reloadCaptcha() }

    fun update(field: String, value: String) {
        input = input + (field to value)
        submit.clearError(field)
    }

    // die beiden Buttons teilen sich diese Abfolge: Senden und, im Fehlerfall,
    // Fehlermeldung und NEUES Bild
    fun attempt(action: suspend () -> Unit) {
        scope.launch {
            d.messages.clear()
            if (!submit.send(action)) {
                input = input + ("captcha" to "")
                reloadCaptcha()
            }
        }
    }

    // bei Erfolg ist hier nichts weiter zu tun: Die Navigation wechselt den Bildschirm
    fun logIn() = attempt {
        d.session.login(input.getValue("login").trim(), input.getValue("password"), captcha?.id ?: "", input.getValue("captcha"))
    }

    fun createAccount() = attempt {
        d.api.registrationAccess(captcha?.id ?: "", input.getValue("captcha"))
        onRegister()
    }

    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
        Text(t("LOGIN.TITLE"), style = MaterialTheme.typography.headlineSmall)
        Spacer(Modifier.height(12.dp))
        // autofillType: Der Passwortmanager des Smartphones kann das Formular ausfüllen
        InputField(
            label = "LOGIN.LOGIN_LABEL",
            value = input.getValue("login"),
            onChange = { update("login", it) },
            error = submit.errors["login"],
            autofillType = ContentType.Username,
        )
        InputField(
            label = "LOGIN.PASSWORD_LABEL",
            secret = true,
            value = input.getValue("password"),
            onChange = { update("password", it) },
            error = submit.errors["password"],
            autofillType = ContentType.Password,
        )
        CaptchaField(
            svg = captcha?.svg,
            value = input.getValue("captcha"),
            onChange = { update("captcha", it) },
            onReload = { scope.launch { reloadCaptcha() } },
            error = submit.errors["captcha"],
        )
        Spacer(Modifier.height(8.dp))
        Button(onClick = { logIn() }, enabled = !submit.inProgress, modifier = Modifier.fillMaxWidth()) { Text(t("LOGIN.SUBMIT")) }
        Spacer(Modifier.height(12.dp))
        OutlinedButton(onClick = { createAccount() }, enabled = !submit.inProgress, modifier = Modifier.fillMaxWidth()) {
            Text(t("LOGIN.CREATE_ACCOUNT"))
        }
        Text(
            t("LOGIN.CREATE_ACCOUNT_HELP"),
            textAlign = TextAlign.Center,
            style = MaterialTheme.typography.bodySmall,
            modifier = Modifier.fillMaxWidth().padding(top = 4.dp),
        )
        Spacer(Modifier.height(16.dp))
        DemoAccounts()
    }
}

// die Demo-Konten
@Composable
private fun DemoAccounts() {
    val style = MaterialTheme.typography.bodySmall
    Text(t("LOGIN.DEMO_ACCOUNTS"), style = style, color = Color.DarkGray)
    for ((accounts, key) in listOf(
        "admin" to "LOGIN.DEMO_ADMIN",
        "pelissier, tatou, dupont" to "LOGIN.DEMO_DOCTOR",
        "martin, durand, bistrou, german" to "LOGIN.DEMO_USER",
    )) {
        Text(
            buildAnnotatedString {
                append("• ")
                withStyle(SpanStyle(fontFamily = FontFamily.Monospace)) { append(accounts) }
                append(" - ${t(key)}")
            },
            style = style,
            color = Color.DarkGray,
        )
    }
}
  • Zeile 32: die Eingabe, ein Feld [Map] Feld → Wert, von [rememberSaveable] gespeichert: Sie übersteht einen Sprachwechsel;
  • Zeilen 61–70: ein neues Bild nach JEDEM Versuch: Ein Bild wird nur einmal verwendet;
  • Zeile 89: Bei Erfolg ist nichts weiter zu tun: Die Sitzung ändert sich, und die Navigation verlässt den Anmeldebildschirm.

11.12.4. pages/SchedulePage.kt

// =========================================================================
// pages/SchedulePage.kt - der Bildschirm des Terminkalenders
// -------------------------------------------------------------------------
// Drei Blöcke, wie bei den anderen Clients:
//   1. die Wahl des Arztes und des Tages;
//   2. der Terminkalender dieses Arztes an diesem Tag;
//   3. der Buchungsdialog eines Zeitfensters: eine andere Route,
//      Screens.Booking, darüber angezeigt (siehe BookingDialog.kt).
//
// DER GESAMTE Zustand des Bildschirms steckt in seiner ROUTE: Screens.Schedule(doctorId, day).
// Der Bildschirm LEITET daraus ab, was er anzeigt, und die Aktionen des Benutzers
// ändern die Route (onView, onBook); der Zurück-Button des Smartphones
// schließt den Buchungsdialog.
//
// Was jeder sieht und tun kann, entscheidet der SERVER (Felder
// patient, mine, bookable, appointmentId jedes Zeitfensters): Der Bildschirm
// zeigt es nur an. Ein Patient erhält nicht einmal den Namen der anderen Patienten.
// =========================================================================
@file:OptIn(ExperimentalMaterial3Api::class)

package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.DatePicker
import androidx.compose.material3.DatePickerDialog
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberDatePickerState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.Schedule
import fr.stahe.rdvmedecins.api.ScheduleSlot
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.Role
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.today
import fr.stahe.rdvmedecins.fromMillis
import fr.stahe.rdvmedecins.isValidDate
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.longDate
import fr.stahe.rdvmedecins.toMillis
import fr.stahe.rdvmedecins.widgets.Tag
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.DropdownList
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch

// der Schlüssel des Terminkalenders eines Arztes an einem bestimmten Tag im Cache
fun scheduleKey(doctorId: Int?, day: String) = "schedule/$doctorId/$day"

@Composable
fun SchedulePage(
    doctorId: Int?,
    day: String?, // unverändert aus der Route: möglicherweise ungültig
    onView: (Int?, String) -> Unit,
    onBook: (Int?, String, Int) -> Unit,
    onMyArea: () -> Unit,
) {
    val d = LocalDependencies.current
    val user = d.session.user
    val confirmation = rememberConfirmation(d.messages)
    val scope = rememberCoroutineScope()
    // der Tag: der aus der Route, wenn er gültig ist, sonst heute
    val invalidDay = day != null && !isValidDate(day)
    val theDay = if (day != null && !invalidDay) day else today()

    var doctors by remember { mutableStateOf(listOf<Person>()) }
    // der Terminkalender (null, solange er nicht eingetroffen ist oder wenn es keinen gibt)
    var schedule by remember { mutableStateOf<Schedule?>(null) }
    var loading by remember { mutableStateOf(false) }

    // die Ärzte: einmal gelesen (Cache); ein Fehler wird unten auf dem Bildschirm angezeigt
    LaunchedEffect(Unit) {
        try {
            doctors = d.cache.read("doctors") { d.api.list(PersonType.DOCTORS) }
        } catch (e: ApiError) {
            d.messages.showApiError(e)
        }
        if (invalidDay) d.messages.showError("ERRORS.INVALID_DATE")
    }

    // der Terminkalender: wird erneut gelesen, wenn sich die Route ändert (anderer Arzt, anderer Tag) oder wenn der
    // Cache für ungültig erklärt wird (Buchung, Stornierung: d.cache.version ändert sich).
    // Ohne Arzt in der Route sieht ein DOCTOR SEINEN Terminkalender (der Server
    // findet ihn anhand des Tokens); die anderen sehen nichts
    val hasSchedule = !invalidDay && (doctorId != null || user?.role == Role.DOCTOR)
    LaunchedEffect(doctorId, theDay, d.cache.version) {
        if (!hasSchedule) {
            schedule = null
            return@LaunchedEffect
        }
        loading = true
        try {
            schedule = d.cache.read(scheduleKey(doctorId, theDay)) { d.api.schedule(doctorId, theDay) }
        } catch (e: ApiError) {
            schedule = null
            d.messages.showApiError(e)
        }
        loading = false
    }

    // der Server ist die Referenz: Nach einer Stornierung wird der Terminkalender erneut gelesen
    // (und der Patientenbereich, der den Termin anzeigt)
    fun cancel(c: ScheduleSlot) {
        val appointmentId = c.appointmentId ?: return
        scope.launch {
            if (!confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) return@launch
            try {
                d.api.cancelAppointment(appointmentId)
                d.messages.showSuccess("SCHEDULE.CANCELLED")
            } catch (e: ApiError) {
                d.messages.showApiError(e)
            }
            d.cache.invalidate("my-area")
            d.cache.invalidate("schedule")
        }
    }

    val a = schedule
    // der angezeigte Arzt: der aus der Route oder der des empfangenen Terminkalenders (DOCTOR)
    val shownId = doctorId ?: a?.doctor?.id
    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
        // 1. die Wahl des Arztes und des Tages. key: Ändert sich die Route, wird das
        // Formular neu erstellt und beginnt wieder mit den neuen Werten
        androidx.compose.runtime.key(shownId, theDay) {
            DoctorDayPicker(doctors = doctors, doctorId = shownId, day = theDay, onView = onView)
        }
        // Patient, der bereits einen bevorstehenden Termin hat: warum es keinen Button "Book" gibt
        a?.info?.let { info ->
            Card(colors = CardDefaults.cardColors(containerColor = Color(0xFFE1F5FE)), modifier = Modifier.padding(top = 8.dp)) {
                ListItem(
                    colors = androidx.compose.material3.ListItemDefaults.colors(containerColor = Color.Transparent),
                    headlineContent = { Text(t(info)) },
                    trailingContent = { TextButton(onClick = onMyArea) { Text(t("APP.MENU_MY_AREA")) } },
                )
            }
        }
        Spacer(Modifier.height(8.dp))
        when {
            loading && a == null -> Box(Modifier.fillMaxWidth().padding(24.dp), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
            a != null -> ScheduleView(
                schedule = a,
                // "Book" ändert die ROUTE: Der Buchungsdialog öffnet sich
                onBook = { c -> onBook(shownId, theDay, c.id) },
                onCancel = ::cancel,
            )
            else -> Text(t("SCHEDULE.EMPTY_STATE"), Modifier.padding(16.dp))
        }
    }
    ConfirmDialog(confirmation)
}

// -------------------------------------------------------------------------
// 1. die Wahl des Arztes und des Tages: ein kleines Formular, dessen Zustand
// nur vor dem Senden nützlich ist. Es BEGINNT mit den Werten der Route.
// -------------------------------------------------------------------------
@Composable
private fun DoctorDayPicker(doctors: List<Person>, doctorId: Int?, day: String, onView: (Int?, String) -> Unit) {
    var id by rememberSaveable { mutableStateOf(doctorId) }
    var theDay by rememberSaveable { mutableStateOf(day) }
    var calendar by remember { mutableStateOf(false) }
    val language = LocalTranslations.current.language
    // der gewählte Arzt muss in der Liste sein (sonst: keiner)
    val knownId = id.takeIf { i -> doctors.any { it.id == i } }
    // t() ist eine @Composable-Funktion: Wir übersetzen VOR dem Text-Lambda, das keine ist
    val prompt = t("DOCTOR_DAY_PICKER.CHOOSE_DOCTOR")
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(12.dp)) {
            DropdownList(
                label = t("DOCTOR_DAY_PICKER.DOCTOR_LABEL"),
                value = knownId,
                choices = listOf<Int?>(null) + doctors.map { it.id },
                text = { i -> doctors.find { it.id == i }?.label ?: prompt },
                onChange = { id = it },
                modifier = Modifier.fillMaxWidth(),
            )
            Spacer(Modifier.height(8.dp))
            // der Tag: ein schreibgeschütztes Feld; eine Berührung öffnet den Kalender
            Box {
                OutlinedTextField(
                    value = longDate(theDay, language),
                    onValueChange = {},
                    readOnly = true,
                    label = { Text(t("DOCTOR_DAY_PICKER.DAY_LABEL")) },
                    trailingIcon = { Icon(Icons.Default.DateRange, contentDescription = t("DOCTOR_DAY_PICKER.CHOOSE_DAY")) },
                    modifier = Modifier.fillMaxWidth(),
                )
                // eine transparente Fläche über dem Feld, die die Berührung empfängt
                Box(Modifier.matchParentSize().clickable { calendar = true })
            }
            Spacer(Modifier.height(12.dp))
            Button(onClick = { onView(knownId, theDay) }, enabled = knownId != null, modifier = Modifier.fillMaxWidth()) {
                Text(t("DOCTOR_DAY_PICKER.VIEW_SCHEDULE"))
            }
        }
    }
    if (calendar) {
        val state = rememberDatePickerState(initialSelectedDateMillis = toMillis(theDay))
        DatePickerDialog(
            onDismissRequest = { calendar = false },
            // die Texte OK / Abbrechen von Android in der Sprache der Anwendung
            confirmButton = {
                TextButton(onClick = {
                    state.selectedDateMillis?.let { theDay = fromMillis(it) }
                    calendar = false
                }) { Text(stringResource(android.R.string.ok)) }
            },
            dismissButton = { TextButton(onClick = { calendar = false }) { Text(stringResource(android.R.string.cancel)) } },
        ) { DatePicker(state = state) }
    }
}

// -------------------------------------------------------------------------
// 2. der Terminkalender
// -------------------------------------------------------------------------
@Composable
private fun ScheduleView(schedule: Schedule, onBook: (ScheduleSlot) -> Unit, onCancel: (ScheduleSlot) -> Unit) {
    val language = LocalTranslations.current.language
    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(vertical = 8.dp)) {
            ListItem(
                headlineContent = { Text("${t("SCHEDULE.TITLE_PREFIX")} ${longDate(schedule.day, language)}", style = MaterialTheme.typography.titleMedium) },
                supportingContent = { Text(schedule.doctor.label) },
            )
            if (schedule.slots.isEmpty()) Text(t("SCHEDULE.NO_SLOTS"), Modifier.padding(16.dp))
            for (c in schedule.slots) {
                HorizontalDivider()
                Row(
                    verticalAlignment = Alignment.CenterVertically,
                    modifier = Modifier
                        .fillMaxWidth()
                        // die buchbaren Zeitfenster sind leicht eingefärbt
                        .background(if (c.bookable) Color(0xFFE8F5E9) else Color.Transparent)
                        .padding(horizontal = 12.dp, vertical = 6.dp),
                ) {
                    Text(timeRange(c), fontWeight = FontWeight.Medium, modifier = Modifier.width(96.dp))
                    Box(Modifier.weight(1f)) {
                        when {
                            c.free -> Tag(t("SCHEDULE.FREE"), Color(0xFF2E7D32))
                            c.patient != null -> Tag(c.patient.label, if (c.mine) Color(0xFF3F51B5) else Color(0xFF757575))
                            else -> Tag(t("SCHEDULE.BOOKED_BY_OTHER"), Color(0xFF757575))
                        }
                    }
                    when {
                        c.bookable -> OutlinedButton(onClick = { onBook(c) }) { Text(t("SCHEDULE.BOOK")) }
                        c.appointmentId != null -> OutlinedButton(
                            onClick = { onCancel(c) },
                            colors = ButtonDefaults.outlinedButtonColors(contentColor = Color(0xFFC62828)),
                        ) { Text(t("SCHEDULE.CANCEL_APPOINTMENT")) }
                    }
                }
            }
        }
    }
}
  • Zeile 91: der Schlüssel des Terminkalenders im Cache;
  • Zeilen 115–117: Ärzte, einmal gelesen (Cache);
  • Zeilen 129–136: der Terminkalender, neu gelesen, wenn sich die Route ändert oder der Cache invalidiert wird;
  • Zeilen 149–157: Stornierung: Bestätigung, Anfrage, Invalidierung des Caches;
  • Zeilen 200–230: Auswahl des Arztes und des Tages; der Tag ist ein schreibgeschütztes Feld, von einer transparenten Überlagerung bedeckt, die den Kalender öffnet;
  • Zeilen 259–274: der Terminkalender: Was jeder Benutzer sieht und tun kann, bestimmt der SERVER.

11.12.5. pages/PatientAreaPage.kt

// =========================================================================
// pages/PatientAreaPage.kt - "My area" (Rolle USER)
// -------------------------------------------------------------------------
// Der Startbildschirm des Patienten, direkt nach der Anmeldung:
//   - zwei Optionen: [Manage my account] und [View a schedule];
//   - sein bevorstehender Termin, falls er einen hat, mit der Möglichkeit, ihn zu stornieren.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)

package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.AccountCircle
import androidx.compose.material.icons.filled.DateRange
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.MyArea
import fr.stahe.rdvmedecins.timeRange
import fr.stahe.rdvmedecins.i18n.LocalTranslations
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.longDate
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch

@Composable
fun PatientAreaPage(onMyAccount: () -> Unit, onSchedule: (Int?, String?) -> Unit) {
    val d = LocalDependencies.current
    val language = LocalTranslations.current.language
    val confirmation = rememberConfirmation(d.messages)
    val scope = rememberCoroutineScope()
    var area by remember { mutableStateOf<MyArea?>(null) }

    LaunchedEffect(d.cache.version) {
        try {
            area = d.cache.read("my-area") { d.api.myArea() }
        } catch (e: ApiError) {
            d.messages.showApiError(e)
        }
    }

    fun cancel(appointmentId: Int) {
        scope.launch {
            if (!confirmation.confirm("SCHEDULE.CANCEL_CONFIRM")) return@launch
            try {
                d.api.cancelAppointment(appointmentId)
                d.messages.showSuccess("SCHEDULE.CANCELLED")
            } catch (e: ApiError) {
                d.messages.showApiError(e)
            }
            // der Bereich UND die Terminkalender haben sich geändert
            d.cache.invalidate("my-area")
            d.cache.invalidate("schedule")
        }
    }

    val e = area
    if (e == null) {
        Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
        return
    }
    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
        Text(t("AREA.HELLO", mapOf("name" to e.patient.label)), style = MaterialTheme.typography.headlineSmall, modifier = Modifier.padding(4.dp))
        Option(Icons.Default.AccountCircle, t("AREA.MANAGE_ACCOUNT"), t("AREA.MANAGE_ACCOUNT_HELP"), onMyAccount)
        Option(Icons.Default.DateRange, t("AREA.VIEW_SCHEDULE"), t("AREA.VIEW_SCHEDULE_HELP")) { onSchedule(null, null) }
        Spacer(Modifier.height(8.dp))
        Card(Modifier.fillMaxWidth()) {
            Column(Modifier.padding(12.dp)) {
                Text(t("AREA.MY_APPOINTMENT"), style = MaterialTheme.typography.titleMedium)
                // normalerweise nur einer (Regel "ein bevorstehender Termin zur Zeit"),
                // aber der Bildschirm kann mehrere anzeigen
                for (appt in e.appointments) {
                    Spacer(Modifier.height(8.dp))
                    Text("${longDate(appt.day, language)}, ${timeRange(appt.slot)}", fontWeight = FontWeight.SemiBold)
                    Text(appt.doctor.label)
                    FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                        // der Terminkalender des Arztes an diesem Tag: Der Patient sieht darin seinen Namen
                        TextButton(onClick = { onSchedule(appt.doctor.id, appt.day) }) { Text(t("AREA.SEE_IN_SCHEDULE")) }
                        OutlinedButton(
                            onClick = { cancel(appt.id) },
                            colors = ButtonDefaults.outlinedButtonColors(contentColor = Color(0xFFC62828)),
                        ) { Text(t("AREA.CANCEL_APPOINTMENT")) }
                    }
                }
                if (e.appointments.isEmpty()) Text(t("AREA.NO_APPOINTMENT"), color = Color.Gray, modifier = Modifier.padding(top = 8.dp))
            }
        }
    }
    ConfirmDialog(confirmation)
}

// eine Options-"Karte", die berührt wird, um einen Bildschirm zu öffnen
@Composable
private fun Option(icon: ImageVector, title: String, help: String, onClick: () -> Unit) {
    Card(Modifier.fillMaxWidth().padding(vertical = 4.dp).clickable(onClick = onClick)) {
        ListItem(
            leadingContent = { Icon(icon, contentDescription = null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(32.dp)) },
            headlineContent = { Text(title, style = MaterialTheme.typography.titleMedium) },
            supportingContent = { Text(help) },
            trailingContent = { Icon(Icons.AutoMirrored.Filled.KeyboardArrowRight, contentDescription = null) },
        )
    }
}

11.12.6. pages/PersonsConfig.kt

// =========================================================================
// pages/PersonsConfig.kt - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Verwaltungsbildschirme der Ärzte und der Clients sind IDENTISCH: dieselbe
// Liste, dasselbe Formular. Wir schreiben sie EINMAL (PersonsPage.kt,
// PersonFormPage.kt); nur die Adresse der API und die
// Schlüssel der Beschriftungen ändern sich und werden hier beschrieben. Die Route übergibt jedem Bildschirm den Typ.
// =========================================================================
package fr.stahe.rdvmedecins.pages

import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType

data class PersonKeys(
    val title: String, // "Doctors"
    val add: String, // "Add a doctor"
    val edit: String, // "Edit a doctor"
    val empty: String, // "No doctors."
    val confirmDelete: String,
    val added: String, // "Doctor {{name}} has been added (login: {{login}})."
    val updated: String,
    val deleted: String,
    val notFound: String, // der Datensatz wurde zwischenzeitlich gelöscht
)

// die Schlüssel eines Typs: nur einmal geschrieben, dank des Präfixes "DOCTORS." oder "CLIENTS."
fun keys(type: PersonType): PersonKeys {
    val p = if (type == PersonType.DOCTORS) "DOCTORS" else "CLIENTS"
    return PersonKeys(
        title = "$p.TITLE",
        add = "$p.ADD",
        edit = "$p.EDIT",
        empty = "$p.EMPTY",
        confirmDelete = "$p.DELETE_CONFIRM",
        added = "$p.ADDED",
        updated = "$p.UPDATED",
        deleted = "$p.DELETED",
        notFound = if (type == PersonType.DOCTORS) "ERRORS.DOCTOR_NOT_FOUND" else "ERRORS.PATIENT_NOT_FOUND",
    )
}

// {{name}} und {{login}} der Meldungen "added / updated / deleted"
fun messageParams(p: Person) = mapOf("name" to "${p.firstName} ${p.lastName}", "login" to (p.login ?: ""))

11.12.7. pages/PersonsPage.kt

// =========================================================================
// pages/PersonsPage.kt - die Liste der Ärzte ODER der Clients (ADMIN)
// -------------------------------------------------------------------------
// Ein einziger Bildschirm für beide: Der Typ (Ärzte oder Clients) kommt über die
// Route an; die für jeden spezifischen Beschriftungen stehen in PersonsConfig.kt.
// Auf einem Smartphone passt eine Tabelle mit fünf Spalten nicht: eine Listenzeile
// pro Person (Name, Login) mit ihren zwei Buttons; der runde Button
// "+" (FloatingActionButton) fügt eine Person hinzu.
// Die Liste ist eine LazyColumn: Nur die sichtbaren Zeilen werden aufgebaut.
// =========================================================================
package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material.icons.filled.Edit
import androidx.compose.material.icons.outlined.Delete
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExtendedFloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.ListItem
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.Person
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch

@Composable
fun PersonsPage(type: PersonType, onAdd: () -> Unit, onEdit: (Int) -> Unit) {
    val d = LocalDependencies.current
    val c = keys(type)
    val confirmation = rememberConfirmation(d.messages)
    val scope = rememberCoroutineScope()
    // null: noch nicht geladen
    var list by remember(type) { mutableStateOf<List<Person>?>(null) }
    var failed by remember(type) { mutableStateOf(false) }

    // wird erneut gelesen, wenn sich der Typ ändert oder der Cache für ungültig erklärt wird
    LaunchedEffect(type, d.cache.version) {
        try {
            list = d.cache.read(type.path) { d.api.list(type) }
        } catch (e: ApiError) {
            failed = true
            d.messages.showApiError(e)
        }
    }

    fun delete(p: Person) {
        scope.launch {
            if (!confirmation.confirm(c.confirmDelete)) return@launch
            try {
                d.api.delete(type, p.id)
                d.messages.showSuccess(c.deleted, messageParams(p))
            } catch (e: ApiError) {
                // ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
                d.messages.showApiError(e)
            }
            d.cache.invalidate(type.path)
        }
    }

    Box(Modifier.fillMaxSize()) {
        val l = list
        if (l == null) {
            // noch nicht geladen (oder das Laden ist fehlgeschlagen: Die Meldung steht unten auf dem Bildschirm)
            if (!failed) CircularProgressIndicator(Modifier.align(Alignment.Center))
        } else {
            // etwas Platz unten, damit die letzte Zeile nicht unter dem schwebenden Button verborgen wird
            LazyColumn(contentPadding = PaddingValues(start = 8.dp, top = 8.dp, end = 8.dp, bottom = 88.dp)) {
                item { Text(t(c.title), style = MaterialTheme.typography.headlineSmall, modifier = Modifier.padding(8.dp)) }
                if (l.isEmpty()) item { ListItem(headlineContent = { Text(t(c.empty)) }) }
                // eine Zeile pro Person; key: die Identität der Zeile
                items(l, key = { it.id }) { p ->
                    Card(Modifier.padding(vertical = 4.dp)) {
                        ListItem(
                            leadingContent = {
                                Box(Modifier.size(40.dp).background(MaterialTheme.colorScheme.primaryContainer, CircleShape), contentAlignment = Alignment.Center) {
                                    Text("${p.firstName.first()}${p.lastName.first()}")
                                }
                            },
                            headlineContent = { Text(p.label) },
                            supportingContent = { Text(p.login ?: "", fontFamily = FontFamily.Monospace) },
                            trailingContent = {
                                Row {
                                    IconButton(onClick = { onEdit(p.id) }) { Icon(Icons.Default.Edit, contentDescription = t("PERSONS.EDIT")) }
                                    IconButton(onClick = { delete(p) }) {
                                        Icon(Icons.Outlined.Delete, contentDescription = t("PERSONS.DELETE"), tint = Color(0xFFC62828))
                                    }
                                }
                            },
                        )
                    }
                }
            }
        }
        ExtendedFloatingActionButton(
            onClick = onAdd,
            icon = { Icon(Icons.Default.Add, contentDescription = null) },
            text = { Text(t(c.add)) },
            modifier = Modifier.align(Alignment.BottomEnd).padding(16.dp),
        )
    }
    ConfirmDialog(confirmation)
}
  • Zeile 97: eine [LazyColumn]: Nur die sichtbaren Zeilen werden erzeugt (Äquivalent zu [ListView.builder] aus [Flutter]); [contentPadding] lässt unter der letzten Zeile Platz für die schwebende Schaltfläche;
  • Zeile 124: die schwebende Schaltfläche ([ExtendedFloatingActionButton]), die eine Person hinzufügt.

11.12.8. pages/PersonFormPage.kt

// =========================================================================
// pages/PersonFormPage.kt - Erstellung ODER Aktualisierung eines Arztes
// oder eines Clients (ADMIN)
// -------------------------------------------------------------------------
//     Screens.Person(DOCTORS)          -> Erstellung (keine id)
//     Screens.Person(DOCTORS, id = 3)  -> Aktualisierung
// Zwei Komponenten:
//   - PersonFormPage liest den zu aktualisierenden Datensatz (falls vorhanden);
//   - Form wird erst angezeigt, nachdem der Datensatz gelesen wurde: Es BEGINNT mit
//     dessen Werten (Anfangszustand), ohne sie später kopieren zu müssen.
// Hier wird keine Regel geprüft: Der Server validiert alles, und seine Fehler
// werden unter den Feldern angezeigt (siehe widgets/FormSubmit.kt).
// Die zusammen mit dem Datensatz gelesene VERSION geht mit der Aktualisierung zurück: Hat ein anderer
// ADMIN ihn zwischenzeitlich aktualisiert, antwortet der Server mit 409 CONCURRENT_UPDATE.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)

package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.FormData
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.PersonType
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch

private val empty = mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "")

@Composable
fun PersonFormPage(type: PersonType, id: Int?, onList: () -> Unit) {
    val d = LocalDependencies.current
    // die Anfangswerte: leer (Erstellung) oder die des gelesenen Datensatzes
    var initial by remember { mutableStateOf<FormData?>(if (id == null) empty else null) }

    if (id != null) {
        LaunchedEffect(id) {
            try {
                // OHNE Cache: Der Datensatz muss aktuell sein (sonst würde das Formular
                // mit einer veralteten Version beginnen: 409 CONCURRENT_UPDATE)
                val p = d.api.read(type, id)
                initial = mapOf("title" to p.title, "firstName" to p.firstName, "lastName" to p.lastName, "login" to (p.login ?: ""), "password" to "", "version" to p.version)
            } catch (e: ApiError) {
                // Datensatz, der nicht existiert (zwischenzeitlich gelöscht ...): zurück zur Liste
                d.messages.flash(e.key, e.params, success = false)
                onList()
            }
        }
    }
    val start = initial
    if (start == null) {
        Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
    } else {
        Form(type, id, start, onList)
    }
}

// das Formular selbst
@Composable
private fun Form(type: PersonType, id: Int?, initial: FormData, onList: () -> Unit) {
    val d = LocalDependencies.current
    val c = keys(type)
    val creating = id == null
    val submit = remember { FormSubmit(d.messages) }
    // eine bearbeitbare KOPIE der Anfangswerte
    var input by rememberSaveable { mutableStateOf(initial) }
    val scope = rememberCoroutineScope()

    fun update(field: String, value: String) {
        input = input + (field to value)
        submit.clearError(field)
    }

    fun save() {
        scope.launch {
            val succeeded = submit.send {
                val p = if (id == null) d.api.add(type, input) else d.api.update(type, id, input)
                d.messages.flash(if (creating) c.added else c.updated, messageParams(p))
            }
            val key = d.messages.error?.key
            if (succeeded) {
                d.cache.invalidate(type.path) // die Liste hat sich geändert
                onList()
            } else if (key == c.notFound) {
                // von einem anderen ADMIN zwischenzeitlich gelöscht: zurück zur Liste
                d.messages.flash(key, success = false)
                onList()
            }
        }
    }

    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
        Text(t(if (creating) c.add else c.edit), style = MaterialTheme.typography.headlineSmall)
        Spacer(Modifier.height(8.dp))
        PersonFields(values = input, errors = submit.errors, onChange = ::update)
        Spacer(Modifier.height(16.dp))
        Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
        InputField(
            label = "PERSONS.LOGIN_LABEL",
            maxLength = 30,
            value = input["login"] as String,
            onChange = { update("login", it) },
            error = submit.errors["login"],
            help = if (creating) "PERSONS.LOGIN_HELP_CREATE" else "PERSONS.LOGIN_HELP_EDIT",
        )
        // nie vorausgefüllt: Das Passwort kommt nie vom Server zurück
        InputField(
            label = "PERSONS.PASSWORD_LABEL",
            secret = true,
            maxLength = 72,
            value = input["password"] as String,
            onChange = { update("password", it) },
            error = submit.errors["password"],
            params = submit.params,
            help = if (creating) "PERSONS.PASSWORD_HELP_CREATE" else "PERSONS.PASSWORD_HELP_EDIT",
        )
        Spacer(Modifier.height(16.dp))
        FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Button(onClick = { save() }, enabled = !submit.inProgress) { Text(t("PERSONS.SAVE")) }
            OutlinedButton(onClick = onList) { Text(t("PERSONS.BACK")) }
        }
    }
}

11.12.9. pages/RegisterPage.kt

// =========================================================================
// pages/RegisterPage.kt - "Create a patient account"
// -------------------------------------------------------------------------
// Wir gelangen nur hierher, nachdem das CAPTCHA des Anmeldebildschirms übernommen wurde
// (Button "Create a patient account"): Der Server hat dann einen
// Pass (ein Cookie) ausgestellt. Der Bildschirm prüft ihn, sobald er sich öffnet (GET
// /api/register/access): ohne Pass zurück zur Anmeldung.
// Dieselben Felder wie im Formular des ADMIN, aber Login und
// Passwort sind Pflicht, mit Bestätigung.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)

package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.autofill.ContentType
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import kotlinx.coroutines.launch

// Mindestlänge eines von einem Patienten gewählten Passworts: derselbe Wert
// wie beim Server (der bei dem Fehler PASSWORD_TOO_SHORT auch {min} sendet)
const val PASSWORD_MIN = "6"

@Composable
fun RegisterPage(onLogin: (String) -> Unit) {
    val d = LocalDependencies.current
    val submit = remember { FormSubmit(d.messages) }
    var input by rememberSaveable {
        mutableStateOf(mapOf("title" to "Mr", "firstName" to "", "lastName" to "", "login" to "", "password" to "", "confirmation" to ""))
    }
    val scope = rememberCoroutineScope()

    // der für diesen Bildschirm EIGENE Guard: ohne Pass zurück zur Anmeldung
    LaunchedEffect(Unit) {
        val valid = runCatching { d.api.registrationAccessStatus() }.getOrDefault(false)
        if (!valid) {
            d.messages.flash("ERRORS.CAPTCHA_BEFORE_ACCOUNT", success = false)
            onLogin("")
        }
    }

    fun update(field: String, value: String) {
        input = input + (field to value)
        submit.clearError(field)
    }

    fun create() {
        scope.launch {
            var login = ""
            val succeeded = submit.send { login = d.api.register(input) }
            if (succeeded) {
                // zurück zum Anmeldebildschirm, Login vorausgefüllt
                d.messages.flash("REGISTRATION.DONE", mapOf("login" to login))
                onLogin(login)
            } else if (d.messages.error?.key == "ERRORS.CAPTCHA_BEFORE_ACCOUNT") {
                // abgelaufener Pass (15 Minuten): zurück zum CAPTCHA
                d.messages.flash("ERRORS.CAPTCHA_BEFORE_ACCOUNT", success = false)
                onLogin("")
            }
        }
    }

    // die Parameter der Hilfemeldung UND der Passwortfehler
    val passwordParams = mapOf("min" to PASSWORD_MIN) + submit.params
    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp)) {
        Text(t("REGISTRATION.TITLE"), style = MaterialTheme.typography.headlineSmall)
        Text(t("REGISTRATION.INTRO"), color = Color.Gray)
        Spacer(Modifier.height(8.dp))
        PersonFields(values = input, errors = submit.errors, onChange = ::update)
        Spacer(Modifier.height(16.dp))
        Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
        InputField(
            label = "PERSONS.LOGIN_LABEL",
            maxLength = 30,
            value = input.getValue("login"),
            onChange = { update("login", it) },
            error = submit.errors["login"],
            help = "REGISTRATION.LOGIN_HELP",
            autofillType = ContentType.NewUsername,
        )
        InputField(
            label = "PERSONS.PASSWORD_LABEL",
            secret = true,
            maxLength = 72,
            value = input.getValue("password"),
            onChange = { update("password", it) },
            error = submit.errors["password"],
            params = passwordParams,
            help = "REGISTRATION.PASSWORD_HELP",
            autofillType = ContentType.NewPassword,
        )
        InputField(
            label = "ACCOUNT.CONFIRMATION_LABEL",
            secret = true,
            maxLength = 72,
            value = input.getValue("confirmation"),
            onChange = { update("confirmation", it) },
            error = submit.errors["confirmation"],
        )
        Spacer(Modifier.height(16.dp))
        FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
            Button(onClick = { create() }, enabled = !submit.inProgress) { Text(t("REGISTRATION.SUBMIT")) }
            OutlinedButton(onClick = { onLogin("") }) { Text(t("REGISTRATION.BACK_TO_LOGIN")) }
        }
    }
}

11.12.10. pages/MyAccountPage.kt

// =========================================================================
// pages/MyAccountPage.kt - "Manage my account" (Rolle USER)
// -------------------------------------------------------------------------
// Zwei unabhängige Formulare:
//   1. die Aktualisierung (Identität, Login, optional neues Passwort);
//   2. die Löschung des Kontos - die auch seine Termine storniert.
// Beide verlangen das AKTUELLE Passwort (vom Server geprüft).
// Zwei Formulare, also zwei FormSubmit (zwei Fehlerbestände). Wie
// beim Personenformular wird die Aktualisierung erst angezeigt, nachdem
// das Konto gelesen wurde, und beginnt mit dessen Werten.
// =========================================================================
@file:OptIn(ExperimentalLayoutApi::class)

package fr.stahe.rdvmedecins.pages

import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.ExperimentalLayoutApi
import androidx.compose.foundation.layout.FlowRow
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Button
import androidx.compose.material3.ButtonDefaults
import androidx.compose.material3.Card
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedCard
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import fr.stahe.rdvmedecins.LocalDependencies
import fr.stahe.rdvmedecins.api.ApiError
import fr.stahe.rdvmedecins.api.MyAccount
import fr.stahe.rdvmedecins.i18n.t
import fr.stahe.rdvmedecins.widgets.InputField
import fr.stahe.rdvmedecins.widgets.PersonFields
import fr.stahe.rdvmedecins.widgets.FormSubmit
import fr.stahe.rdvmedecins.widgets.ConfirmDialog
import fr.stahe.rdvmedecins.widgets.rememberConfirmation
import kotlinx.coroutines.launch

@Composable
fun MyAccountPage(onMyArea: () -> Unit) {
    val d = LocalDependencies.current
    // bei jedem Besuch erneut gelesen, ohne Cache: Seine Version muss aktuell sein
    var account by remember { mutableStateOf<MyAccount?>(null) }
    LaunchedEffect(Unit) {
        try {
            account = d.api.myAccount()
        } catch (e: ApiError) {
            d.messages.showApiError(e)
        }
    }
    Column(Modifier.fillMaxSize().verticalScroll(rememberScrollState()).padding(12.dp)) {
        val c = account
        if (c == null) {
            Box(Modifier.fillMaxWidth().padding(24.dp), contentAlignment = Alignment.Center) { CircularProgressIndicator() }
        } else {
            EditAccount(c, onMyArea)
        }
        Spacer(Modifier.height(12.dp))
        DeleteAccount()
    }
}

// -------------------------------------------------------------------------
// 1. die Aktualisierung
// -------------------------------------------------------------------------
@Composable
private fun EditAccount(account: MyAccount, onMyArea: () -> Unit) {
    val d = LocalDependencies.current
    val submit = remember { FormSubmit(d.messages) }
    val scope = rememberCoroutineScope()
    var input by rememberSaveable {
        mutableStateOf(
            mapOf<String, Any?>(
                "title" to account.title,
                "firstName" to account.firstName,
                "lastName" to account.lastName,
                "login" to account.login,
                "password" to "",
                "confirmation" to "",
                "currentPassword" to "",
                "version" to account.version,
            ),
        )
    }

    fun update(field: String, value: String) {
        input = input + (field to value)
        submit.clearError(field)
    }

    fun save() {
        scope.launch {
            val succeeded = submit.send {
                // der Server hat ein NEUES Token ausgestellt (Name, Login): Die obere Leiste muss folgen
                d.session.update(d.api.updateMyAccount(input))
                d.messages.flash("MY_ACCOUNT.UPDATED")
            }
            if (succeeded) {
                d.cache.invalidate("my-area")
                onMyArea()
            } else {
                // nie ein Passwort im Feld lassen nach einem abgelehnten Senden;
                // der Wert wird OHNE Umweg über update() geändert, um den Fehler nicht
                // zu löschen, den der Server ihm gerade zugeordnet hat
                input = input + ("currentPassword" to "")
            }
        }
    }

    Card(Modifier.fillMaxWidth()) {
        Column(Modifier.padding(16.dp)) {
            Text(t("MY_ACCOUNT.TITLE"), style = MaterialTheme.typography.titleLarge)
            PersonFields(values = input, errors = submit.errors, onChange = ::update)
            Spacer(Modifier.height(12.dp))
            Text(t("PERSONS.ACCOUNT_SECTION"), style = MaterialTheme.typography.titleSmall)
            InputField("PERSONS.LOGIN_LABEL", input["login"] as String, { update("login", it) }, submit.errors["login"], maxLength = 30)
            InputField(
                label = "MY_ACCOUNT.NEW_PASSWORD_LABEL",
                secret = true,
                maxLength = 72,
                value = input["password"] as String,
                onChange = { update("password", it) },
                error = submit.errors["password"],
                params = submit.params,
                help = "PERSONS.PASSWORD_HELP_EDIT",
            )
            InputField(
                label = "ACCOUNT.CONFIRMATION_LABEL",
                secret = true,
                maxLength = 72,
                value = input["confirmation"] as String,
                onChange = { update("confirmation", it) },
                error = submit.errors["confirmation"],
            )
            InputField(
                label = "MY_ACCOUNT.CURRENT_PASSWORD_LABEL",
                secret = true,
                maxLength = 72,
                value = input["currentPassword"] as String,
                onChange = { update("currentPassword", it) },
                error = submit.errors["currentPassword"],
                help = "MY_ACCOUNT.CURRENT_PASSWORD_HELP",
            )
            Spacer(Modifier.height(8.dp))
            FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Button(onClick = { save() }, enabled = !submit.inProgress) { Text(t("PERSONS.SAVE")) }
                OutlinedButton(onClick = onMyArea) { Text(t("MY_ACCOUNT.BACK")) }
            }
        }
    }
}

// -------------------------------------------------------------------------
// 2. die Löschung: ein Formular mit einem einzigen Feld
// -------------------------------------------------------------------------
@Composable
private fun DeleteAccount() {
    val d = LocalDependencies.current
    val submit = remember { FormSubmit(d.messages) }
    val confirmation = rememberConfirmation(d.messages)
    val scope = rememberCoroutineScope()
    var currentPassword by remember { mutableStateOf("") }

    fun delete() {
        scope.launch {
            if (!confirmation.confirm("MY_ACCOUNT.DELETE_CONFIRM")) return@launch
            val succeeded = submit.send { d.api.deleteMyAccount(currentPassword) }
            if (succeeded) {
                // zuerst die Meldung: Sie wird auf dem Anmeldebildschirm angezeigt,
                // wohin uns die Navigation bringt, sobald die Sitzung leer ist
                d.messages.flash("MY_ACCOUNT.DELETED")
                d.session.forget(voluntary = true) // der Server hat das Token-Cookie gelöscht
            }
        }
    }

    OutlinedCard(Modifier.fillMaxWidth(), border = BorderStroke(1.dp, Color(0xFFEF9A9A))) {
        Column(Modifier.padding(16.dp)) {
            Text(t("MY_ACCOUNT.DELETE_TITLE"), style = MaterialTheme.typography.titleLarge, color = Color(0xFFC62828))
            Text(t("MY_ACCOUNT.DELETE_HELP"), color = Color.Gray)
            InputField(
                label = "MY_ACCOUNT.CURRENT_PASSWORD_LABEL",
                secret = true,
                maxLength = 72,
                value = currentPassword,
                onChange = {
                    currentPassword = it
                    submit.clearError("currentPassword")
                },
                error = submit.errors["currentPassword"],
            )
            Button(
                onClick = { delete() },
                enabled = !submit.inProgress,
                colors = ButtonDefaults.buttonColors(containerColor = Color(0xFFC62828)),
            ) { Text(t("MY_ACCOUNT.DELETE_SUBMIT")) }
        }
    }
    ConfirmDialog(confirmation)
}