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:
| 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):


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“:



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



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

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:



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:



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:



Ein Duplikat; ein erfolgreiches Löschen:


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:


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:


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:

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.
| // =========================================================================
// 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
| // =========================================================================
// 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.
| // =========================================================================
// 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 },
)
}
|
| // =========================================================================
// 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"],
)
}
}
|
| // =========================================================================
// 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.
| // =========================================================================
// 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")) }
},
)
}
|
| // =========================================================================
// 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)
}
}
|
| // =========================================================================
// 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))
}
|
| // =========================================================================
// 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
},
)
}
}
}
}
|
| // 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),
)
}
|
| // =========================================================================
// 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)
}
|