11. Fallstudie: Der Flutter-Client für die Anwendung RdvMedecins
11.1. Die Aufgabenstellung
Die Anwendung [RdvMedecins] ermöglicht es, Termine in einer Arztpraxis zu vereinbaren. Der Kurs [NestJS] hat sie als HTML-Anwendung entwickelt, bei der der Server die Seiten erzeugte; die Kurse [Vue.js], [Angular] und [React] schrieben dafür Web-Clients, die im Browser DIESELBEN Seiten erzeugen, auf der Grundlage der JSON-Daten des Servers, die im Kapitel „Der RdvMedecins-Server, eine Blackbox“ vorgestellt wurden. Hier beschreiben wir den [Flutter]-Client: eine mobile Anwendung ([Android]), die sich auch für das Web kompilieren lässt.
Der Client muss alles bieten, was die anderen boten:
- ein Anmeldebildschirm, geschützt durch ein CAPTCHA, 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 Adressen wie die Web-Clients ([/schedule?doctorId=1&day=...]). Auf dem Smartphone sind sie unsichtbar, gliedern aber die App; im Web können Benutzer sie neu laden, als Lesezeichen speichern und mit den Schaltflächen „Zurück“/„Vorwärts“ des Browsers in der App navigieren.
Eine mobile App bringt eigene Anforderungen mit: einen schmalen Bildschirm (keine Tabellen mit fünf Spalten), eine Tastatur, die den halben Bildschirm verdeckt, eine Zurück-Taste, einen Passwortmanager und das Fehlen eines Browsers, der den Token-Cookie speichert.
11.2. Installation und Ausführung
Der JSON-Server muss installiert sein und laufen (siehe Kapitel „Der RdvMedecins-Server: eine Blackbox“). Sie benötigen den CAPTCHA-Testmodus nicht: Sie können das Feld [CAPTCHA_TEST] in der Datei [.env] auf dem Server leer lassen.
In einem Konsolenfenster, das im Ordner [rdvmedecins_flutter] geöffnet ist:
| flutter create --platforms=android,web --org fr.stahe --project-name rdvmedecins_flutter .
flutter pub get
|
Der erste Befehl fügt dem Projekt die plattformspezifischen Ordner ([android/], [web/]) hinzu, wie in den Beispielen; er ändert keine bestehenden Dateien, und die mitgelieferte Datei [android/app/src/main/AndroidManifest.xml] (die aus Beispiel 22) bleibt erhalten. Wählen Sie dann eine der folgenden Möglichkeiten:
| flutter run -d emulator-5554
flutter run -d R58N12ABCDE --dart-define=SERVER=http://192.168.1.20:8080
flutter run -d chrome
|
- Die erste Zeile startet die Anwendung im [Android]-Emulator (der Befehl [flutter devices] listet die verfügbaren Geräte auf). Der Emulator verbindet sich unter der Adresse [10.0.2.2:8080] (siehe Beispiel 22) mit dem Server;
- die zweite Zeile startet die App auf einem echten Smartphone, das per USB (mit aktiviertem „USB-Debugging“ in den Entwickleroptionen) oder per WLAN verbunden ist. Smartphone und Computer müssen sich im selben Netzwerk befinden; geben Sie die Adresse des Computers in diesem Netzwerk an ([ipconfig] unter [Windows]). Die Firewall von [Windows] muss eingehende Verbindungen auf Port 8080 zulassen;
- die dritte in [Chrome], unter der Adresse http://localhost:5173: Der Webentwicklungsserver von [Flutter] leitet /api-Anfragen an den JSON-Server weiter (Datei [web_dev_config.yaml]).
Die Demokonten werden auf dem Anmeldebildschirm aufgelistet (Passwort = Login). Während die Anwendung läuft, löst die Taste [r] in der Konsole nach einer Codeänderung einen „Hot Reload“ aus; [R] startet sie neu; [q] beendet sie.
11.3. Die Anwendung verwenden
Die Screenshots in diesem Abschnitt stammen von einem Smartphone mit einer Auflösung von 1080 × 2340 Pixeln (412 × 891 Punkte).
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
Als [admin] angemeldet, gelangen Sie zum Terminkalender. Die Schaltfläche ☰ öffnet das Menü: die für den Administrator zugänglichen Bildschirme und oben, wer angemeldet ist:
Wählen Sie einen Arzt und ein Datum (das Datum in einem Kalender) und klicken Sie dann auf „Terminkalender anzeigen“. Die URL ändert sich in [/schedule?doctorId=1&day=2026-10-05]. Ein Klick auf „Buchen“ öffnet das Buchungsfenster; die URL ändert sich in [/schedule?doctorId=1&day=2026-10-05&book=3]:
Der Termin wird gespeichert; „Stornieren“ fordert zur Bestätigung auf:
Ein Arzt gelangt direkt zu SEINEM Terminkalender für heute:

11.3.3. Das Patientenportal
Ein Patient ([martin]) ruft „Mein Bereich“ auf. In einem Terminkalender sieht er bei den Zeitfenstern anderer Patienten „Belegt“ und bucht einen Termin für sich selbst, ohne einen bestimmten Patienten auszuwählen:
Sein Termin erscheint unter seinem Namen; die Schaltfläche „Buchen“ ist nicht mehr verfügbar (nur ein bevorstehender Termin). Im Terminkalender eines anderen Arztes, in dem sein Termin nicht erscheint, erklärt eine Meldung, warum er nicht buchen kann. Sein Bereich („Mein Bereich“) zeigt den Termin:
„Mein Konto verwalten“: Jede Änderung erfordert das aktuelle Passwort; die Fehler stammen vom Server:

Im Menü eines Patienten gibt es keinen Eintrag „Ärzte“. Im Web zeigt der Router eine 403-Fehlerseite an, wenn der Patient die Adresse /doctors selbst eingibt (siehe [router.dart]).
11.3.4. Ärzte und Klienten verwalten
Die Liste der Ärzte; ein falsch ausgefüllter Eintrag:
Ein erfolgreiches Hinzufügen; ein Namensvetter; das Löschen eines Arztes mit Terminen wird verweigert:
11.3.5. Ein Konto erstellen
Geben Sie auf dem Anmeldebildschirm das CAPTCHA ein und tippen Sie dann auf „Patientenkonto erstellen“. Das Formular wird vom Server abgelehnt; sobald das Konto erstellt ist, gelangen Sie zum Anmeldebildschirm zurück, wobei die Anmeldedaten bereits ausgefüllt sind:
11.3.6. Auf Französisch; auf einem großen Bildschirm
Das Menü FR / EN in der oberen Leiste zeichnet den Bildschirm lokal neu, ohne Anfragen an den Server. Auf einem breiten Bildschirm (Web, Tablet) bleibt das Menü links eingeblendet:
11.3.7. Sitzung abgelaufen
Läuft das Token ab (oder wird der Cookie gelöscht), erhält die nächste Anfrage eine 401-Antwort; die Anwendung leitet zum Anmeldebildschirm um:

11.4. Architektur des Clients
| rdvmedecins_flutter/
├── pubspec.yaml the libraries, the resources
├── analysis_options.yaml the rules of the code analyzer
├── web_dev_config.yaml the web development server (proxy /api)
├── android/ the Android project (including AndroidManifest.xml)
├── web/ the HTML page of the web version
├── assets/
│ ├── i18n/ the dictionaries fr.json, en.json
│ └── fonts/ the RobotoMono font
├── test/ unit tests; making of the screenshots
└── lib/
├── main.dart the startup
├── config.dart the server address
├── router.dart the screens, their addresses, their access rights
├── formatting.dart the formatting of times and days
├── api/ the API access layer
├── i18n/ the languages
├── state/ session, messages, cache (ChangeNotifier)
├── widgets/ the layout and the reusable widgets
└── pages/ the screens
|
Dies ist die Architektur, die der [Flutter]-Leitfaden („App architecture“) empfiehlt, einfacher erklärt:
- eine Datenschicht ([api/]): die einzige Schicht, die das Paket [http], die URLs und das JSON kennt;
- eine Zustandsschicht ([state/]): [ChangeNotifier]-Objekte, die der gesamten Anwendung bereitgestellt werden ([provider]) und die die Bildschirme beobachten;
- eine Oberflächenschicht ([pages/], [widgets/]): Widgets, die den Zustand anzeigen und Benutzeraktionen weiterleiten.
Die folgende Tabelle vergleicht die HTML-Anwendung aus dem Kurs [NestJS], den [React]-Client und diesen Client:
HTML-Anwendung (NestJS) | React-Client | Flutter-Client |
Der Server rendert jede Seite ([res.render]) | Komponenten rendern die Seiten im Browser | Widgets rendern die Bildschirme auf dem Smartphone |
[views/layout.hbs] und seine Partial Views | [Layout.tsx] und die Komponenten | [layout.dart] (eine [ShellRoute]) und die Widgets |
Routen der Controller | [React Router] | [go_router] |
[JwtAuthGuard], [RolesGuard] | Router-Guards (Middleware) | Die [redirect]-Funktion des Routers |
der Token-Cookie, vom Browser gespeichert | ebenso | Ein HTTP-Client, der Cookies verwaltet (auf dem Smartphone) |
Flash-Meldung in einem Cookie | ein Store namens [Zustand] | ein [ChangeNotifier], [Messages] |
vom Server gelesene Wörterbücher | [i18next] | [Translations] (Beispiel 21) |
Sprache in einem Cookie gespeichert | in [localStorage] | in [shared_preferences] |
bereits gelesene Daten | [TanStack Query] | [Cache] (wenige Zeilen) |
Formular abgelehnt: Der Server lädt die Seite neu | Antwort 400/409, Fehler unter den Feldern | ebenso |
Alle Dateien des Clients werden im Folgenden vorgestellt. Sie sind ausführlich kommentiert; ihre Kommentare sind Teil des Kurses.
11.5. Projektkonfiguration
11.5.1. pubspec.yaml
| # ==========================================================================
# pubspec.yaml - der Flutter-Client der RdvMedecins-Anwendung
# ==========================================================================
name: rdvmedecins_flutter
description: The Flutter client (Android, web) of the RdvMedecins appointment booking application.
publish_to: none
version: 1.0.0
environment:
sdk: ^3.12.0
dependencies:
flutter:
sdk: flutter
flutter_localizations:
sdk: flutter
flutter_web_plugins:
sdk: flutter
intl: any
go_router: ^16.2.0
provider: ^6.1.5
shared_preferences: ^2.5.3
http: ^1.5.0
flutter_svg: ^2.2.1
dev_dependencies:
flutter_test:
sdk: flutter
flutter_lints: ^6.0.0
flutter:
uses-material-design: true
assets:
- assets/i18n/
fonts:
- family: RobotoMono
fonts:
- asset: assets/fonts/RobotoMono-Regular.ttf
- asset: assets/fonts/RobotoMono-Bold.ttf
weight: 700
|
Die Bibliotheken der Beispiele, mit Ausnahme von [flutter_svg]..., das erhalten bleibt: Das CAPTCHA ist ein Bild (SVG). Die einzigen Ressourcen sind die Wörterbücher und die Monospace-Schrift für die Demokonten.
11.5.2. analysis_options.yaml
| # ==========================================================================
# analysis_options.yaml - die Regeln des Dart-Code-Analyzers
# --------------------------------------------------------------------------
# Der Analyzer prüft den Code bereits bei der Eingabe (VS Code unterstreicht die
# Fehler) und mit dem Befehl flutter analyze. Wir gehen von den Regeln aus
# empfohlenen Regeln aus (Paket flutter_lints) ...
# ==========================================================================
include: package:flutter_lints/flutter.yaml
analyzer:
language:
# ... und verschärfen sie: keine implizite Konvertierung eines dynamic-Typs
strict-casts: true
strict-raw-types: true
linter:
rules:
# überall einfache Anführungszeichen, wie in den Beispielen des Kurses
prefer_single_quotes: true
# "final" für eine lokale Variable, die nie neu zugewiesen wird
prefer_final_locals: true
# zu lange Zeichenketten sind erlaubt (Texte der Benutzeroberfläche)
lines_longer_than_80_chars: false
|
Die Regeln des Analyzers, wie in den Beispielen:
- Zeile 9: die vom [Flutter]-Team empfohlenen Regeln;
- Zeilen 14–15: strengere Typprüfung: Ein [dynamic] (wie von [jsonDecode] zurückgegeben) kann nicht ohne ausdrückliche Umwandlung als [String] verwendet werden ([as String] oder Filtern per [Dart] 3);
- Zeilen 20–24: drei Formatierungsregeln.
Der Befehl [flutter analyze] wendet diese Regeln auf das gesamte Projekt an; [VS Code] wendet sie schon während der Eingabe an.
11.5.3. web_dev_config.yaml
| # ==========================================================================
# web_dev_config.yaml - der WEB-Entwicklungsserver von Flutter
# --------------------------------------------------------------------------
# flutter run -d chrome liefert die Anwendung unter http://localhost:5173 aus und
# leitet jede /api/...-Anfrage an den RdvMedecins-JSON-Server (Port 8080) weiter:
# Für den Browser haben die Anwendung und die API denselben Ursprung (kein
# CORS, und das Token-Cookie wird mitgeführt).
# ==========================================================================
server:
host: localhost
port: 5173
proxy:
- target: "http://localhost:8080/"
prefix: "/api/"
|
Die Datei aus Beispiel 22: In der Webentwicklung werden /api-Anfragen an den JSON-Server gesendet.
11.6. Start der Anwendung
11.6.1. lib/config.dart
| // =========================================================================
// lib/config.dart - WO ist der JSON-Server?
// -------------------------------------------------------------------------
// Die Frage stellt sich bei einer Webanwendung, die vom Server selbst ausgeliefert wird, nicht:
// Die Anfragen gehen an denselben Origin wie die Seite
// (eine relative Adresse, /api/...). Eine MOBILE Anwendung hat jedoch keinen
// Origin: Ihr muss die vollständige Adresse des Servers mitgegeben werden.
// - Der Android-Emulator sieht den Computer, auf dem er läuft, unter
// der Adresse 10.0.2.2 (localhost ist für ihn der Emulator selbst);
// - ein echtes Smartphone, das mit demselben WLAN wie der Computer verbunden ist, muss
// die Adresse des Computers in diesem Netzwerk verwenden (192.168.1.20...):
// sie wird beim Start der Anwendung angegeben:
// flutter run --dart-define=SERVER=http://192.168.1.20:8080 ...
// - in der Webentwicklung (flutter run -d chrome) leitet der Entwicklungsserver von Flutter
// die /api-Anfragen an den JSON-Server weiter
// (Datei web_dev_config.yaml): Eine relative Adresse genügt;
// - auf einem Computer (Windows, macOS, Linux): localhost.
// =========================================================================
import 'package:flutter/foundation.dart';
// der von --dart-define=SERVER=... angegebene Wert, standardmäßig ''.
// String.fromEnvironment wird zur KOMPILIERZEIT ausgewertet: Es ist eine Konstante
const _forcedServer = String.fromEnvironment('SERVER');
class Config {
// kIsWeb: true, wenn die Anwendung in einem Browser läuft;
// defaultTargetPlatform: das System (android, iOS, windows ...)
static String serverUrl = _forcedServer.isNotEmpty
? _forcedServer
: kIsWeb
? '' // gleicher Ursprung: relative Adressen
: defaultTargetPlatform == TargetPlatform.android
? 'http://10.0.2.2:8080'
: 'http://localhost:8080';
}
|
Die Serveradresse, abhängig von der Plattform (siehe Beispiel 22):
- Zeile 24: der beim Start über [--dart-define=SERVER=...] angegebene Wert. [String.fromEnvironment] wird zur Kompilierzeit ausgewertet: Die Adresse wird in die erstellte Anwendung eingebettet;
- Zeilen 29–35: andernfalls im Web eine relative Adresse (der Entwicklungsserver, in der Produktion dann der JSON-Server selbst, liefern die Seite UND die API aus), [10.0.2.2] unter [Android] (der Computer, vom Emulator aus gesehen), [localhost] anderswo. [static]: eine Klassenvariable, keine Objektvariable; nicht [final], damit die Tests sie ändern können.
11.6.2. lib/main.dart
| // =========================================================================
// lib/main.dart - der Start der Anwendung
// -------------------------------------------------------------------------
// Wir bauen einmalig die von der gesamten Anwendung gemeinsam genutzten Objekte
// und STELLEN sie dann allen Bildschirmen BEREIT (provider):
// - den HTTP-Client (der auf dem Smartphone das Token-Cookie verwaltet) und die
// API-Zugriffsschicht;
// - die Sitzung (wer ist angemeldet?), die Meldungen, den Daten-Cache;
// - die Übersetzungen (Französisch, Englisch);
// - den Router, der den Bildschirm der aktuellen Adresse anzeigt.
// Zwei Mechanismen verknüpfen diese Objekte miteinander:
// 1. die Antwort 401 auf eine geschützte Anfrage (Sitzung abgelaufen): Wir vergessen
// den Benutzer und bereiten die Meldung vor; der Router, der die
// Sitzung abhört, kehrt dann zum Login-Bildschirm zurück (siehe api/api_client.dart);
// 2. die "Flash"-Meldungen: Am Ende JEDER Navigation verschwinden die Meldungen
// des vorherigen Bildschirms, und die für den nächsten
// Bildschirm hinterlassenen erscheinen (siehe state/messages.dart).
// =========================================================================
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:flutter_web_plugins/url_strategy.dart';
import 'package:go_router/go_router.dart';
import 'package:intl/date_symbol_data_local.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';
import 'api/api_client.dart';
import 'api/http_client.dart';
import 'api/rdvmedecins_api.dart';
import 'state/cache.dart';
import 'state/messages.dart';
import 'state/session.dart';
import 'i18n/translations.dart';
import 'router.dart';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
usePathUrlStrategy(); // im Web: /schedule statt /#/schedule
await initializeDateFormatting();
final storage = await SharedPreferences.getInstance();
final translations = Translations(storage);
await translations.start();
runApp(Application(storage: storage, translations: translations));
}
class Application extends StatefulWidget {
final SharedPreferences storage;
final Translations translations;
const Application({super.key, required this.storage, required this.translations});
@override
State<Application> createState() => _ApplicationState();
}
class _ApplicationState extends State<Application> {
late final ApiClient _client = ApiClient(CookieClient(widget.storage));
late final RdvMedecinsApi _api = RdvMedecinsApi(_client);
late final Session _session = Session(_api);
final Messages _messages = Messages();
final Cache _cache = Cache();
late final GoRouter _router = createRouter(_session, _messages, _api);
String? _address;
@override
void initState() {
super.initState();
// 1. die abgelaufene Sitzung
_client.onSessionExpired = () {
_session.forget();
_cache.clear();
_messages.flash(success: false, key: 'ERRORS.SESSION_EXPIRED');
// kein _router.go('/login'): Der Guard des Routers kümmert sich darum und
// merkt sich den aktuellen Bildschirm (?redirect=...), um dorthin zurückzukehren
};
// die Sitzung ändert sich (Login, Logout): Die für
// den vorherigen Benutzer gelesenen Daten sind nichts mehr wert
_session.addListener(_cache.clear);
// 2. bei jeder abgeschlossenen Navigation (die Adresse hat sich geändert): neue Seite
_router.routerDelegate.addListener(() {
// state: der Bildschirm OBEN auf dem Stack (auch ein mit push aufgelegter Bildschirm)
final address = _router.state.uri.toString();
if (address != _address) {
_address = address;
_messages.newPage();
}
});
}
@override
void dispose() {
_router.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return MultiProvider(
providers: [
// gewöhnliche Objekte...
Provider.value(value: _api),
// ... und Objekte, die ihre Änderungen melden
ChangeNotifierProvider.value(value: _cache),
ChangeNotifierProvider.value(value: _session),
ChangeNotifierProvider.value(value: _messages),
ChangeNotifierProvider.value(value: widget.translations),
],
child: Consumer<Translations>(
builder: (context, translations, _) => MaterialApp.router(
debugShowCheckedModeBanner: false,
onGenerateTitle: (context) => translations.t('APP.TITLE'),
theme: ThemeData(colorSchemeSeed: const Color(0xFF0D6EFD)),
// die Texte von Flutter selbst (Kalender...) in der gewählten Sprache
locale: Locale(translations.language),
supportedLocales: [for (final l in languages) Locale(l)],
localizationsDelegates: GlobalMaterialLocalizations.delegates,
routerConfig: _router,
),
),
);
}
}
|
- Zeilen 37–44: Bevor etwas angezeigt wird, bereiten wir vor, was nötig ist: Webadressen ohne [#] (Beispiel 17), die Namen der Tage und Monate in allen Sprachen ([intl], Beispiel 09), der Speicher des Geräts und das Wörterbuch der Anfangssprache. [WidgetsFlutterBinding.ensureInitialized()]: Diese Operationen benötigen die [Flutter]-Engine, daher starten wir sie vor [runApp];
- Zeilen 58–63: die gemeinsamen Objekte, EINMAL im Zustand des Root-Widgets erzeugt. Jedes erhält bei der Erstellung die Objekte, die es braucht: Das ist Dependency Injection, manuell durchgeführt. [late]: Die Initialisierung erfolgt bei der ersten Verwendung, wenn [widget] bereits existiert;
- Zeilen 70–76: 1. die abgelaufene Sitzung. Die Zugriffsschicht für die API kennt weder die Sitzung noch die Meldungen; ihr wird diese Funktion anvertraut, die sie bei jeder 401-Antwort aufruft. Der Benutzer wird vergessen, der Cache geleert und die Meldung für den nächsten Bildschirm vorbereitet. Der Bildschirmwechsel selbst obliegt dem Router, der die Sitzung beobachtet;
- Zeile 79: Bei jedem Benutzerwechsel wird der Cache geleert: Die für den vorherigen Benutzer gelesenen Daten nützen dem nächsten nichts (ein Patient soll nicht den vom Administrator angesehenen Terminkalender sehen);
- Zeilen 81–88: 2. Flash-Meldungen. Der [routerDelegate] des Routers benachrichtigt seine Listener bei jeder Übertragung; die Adresse wird mit der vorherigen verglichen ([_router.state]: der Bildschirm ganz OBEN im Stapel, auch ein per [push] gestapelter Bildschirm wie das Buchungsfenster), und hat sie sich geändert, wechselt das System zu einer „neuen Seite“: Die Meldungen des vorherigen Bildschirms verschwinden, und die für diesen abgelegten erscheinen (siehe [messages.dart]);
- Zeilen 99–107: Die gemeinsamen Objekte werden allen Bildschirmen bereitgestellt (Beispiel 20). [.value]: Das Objekt existiert bereits; der Provider erzeugt es nicht (und zerstört es auch nicht);
- Zeilen 109–118: die Anwendung selbst, bei jedem Sprachwechsel neu aufgebaut ([Consumer], siehe Beispiel 20): der Titel ([onGenerateTitle]) und die Sprache der Texte von [Flutter] selbst (der Kalender, Tooltips). [colorSchemeSeed]: eine Farbe, aus der [Material] die gesamte Palette ableitet; es ist das Blau von [Bootstrap], der Farbe der Web-Clients.
11.7. Die Zugriffsschicht für die API
11.7.1. lib/api/http_client.dart
| // =========================================================================
// lib/api/http_client.dart - ein HTTP-Client, der COOKIES verwaltet
// -------------------------------------------------------------------------
// Der RdvMedecins-Server legt das JWT-Token in einem COOKIE ab (httpOnly).
// In einem Browser speichert der Browser die Cookies und sendet sie
// bei jeder Anfrage zurück: Der Code der Anwendung muss nichts tun.
// Auf einem Telefon gibt es KEINEN Browser: Es ist Sache der Anwendung,
// seine Rolle zu übernehmen, das heißt:
// 1. den Header "Set-Cookie" jeder Antwort lesen und die Cookies speichern;
// 2. sie im Header "Cookie" jeder Anfrage zurücksenden.
// Dieser HTTP-Client erledigt das, indem er den Client des Pakets http UMHÜLLT
// (http.BaseClient: Es genügt, die Methode send zu schreiben). Die Cookies werden
// außerdem auf dem Gerät gespeichert (shared_preferences): Wir bleiben angemeldet,
// wenn wir die Anwendung beenden und neu starten.
// Im Web tut er nicht mehr als der gewöhnliche Client: Der
// Browser verbietet der Anwendung, diese Header zu lesen oder zu schreiben.
// =========================================================================
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'package:shared_preferences/shared_preferences.dart';
class CookieClient extends http.BaseClient {
static const _key = 'rdvmedecins.cookies';
final http.Client _inner = http.Client();
final SharedPreferences? _storage;
// Cookie-Name -> sein Wert
final Map<String, String> _cookies = {};
CookieClient([this._storage]) {
// die bei einer früheren Nutzung gespeicherten Cookies
final stored = _storage?.getString(_key);
if (stored != null) {
_cookies.addAll((jsonDecode(stored) as Map<String, Object?>).cast<String, String>());
}
}
@override
Future<http.StreamedResponse> send(http.BaseRequest request) async {
if (!kIsWeb && _cookies.isNotEmpty) {
// "rdvmedecins_jwt=eyJhbGci...; other=value"
request.headers['cookie'] = [for (final MapEntry(:key, :value) in _cookies.entries) '$key=$value'].join('; ');
}
final response = await _inner.send(request);
final setCookie = response.headers['set-cookie'];
if (!kIsWeb && setCookie != null) {
_store(setCookie);
}
return response;
}
// Set-Cookie: rdvmedecins_jwt=eyJ...; Max-Age=7200; Path=/api; Expires=Tue, 29 Sep 2026 ...; HttpOnly
// (mehrere Cookies werden durch Kommas getrennt). Wir behalten nur den
// Namen und den Wert jedes Cookies; ein leerer Wert (Logout) löscht es
void _store(String setCookie) {
// ein Name, gefolgt von "=", am Anfang des Headers oder nach einem Komma
for (final m in RegExp(r'(?:^|,)\s*([^=;,\s]+)=([^;]*)').allMatches(setCookie)) {
final name = m[1]!;
final value = m[2]!.trim();
if (value.isEmpty) {
_cookies.remove(name);
} else {
_cookies[name] = value;
}
}
_storage?.setString(_key, jsonEncode(_cookies));
}
@override
void close() => _inner.close();
}
|
Der HTTP-Client aus Beispiel 23, unverändert: Er speichert die empfangenen Cookies (Header [Set-Cookie]) und sendet sie zurück (Header [Cookie]) auf dem Smartphone; im Web überlässt er das dem Browser.
11.7.2. lib/api/api_client.dart
| // =========================================================================
// lib/api/api_client.dart - ALLE Anfragen an die API laufen hier durch
// -------------------------------------------------------------------------
// Übernommen aus common/api.dart der Beispiele, mit einer Neuerung: der
// zentralen Behandlung der Antwort 401.
//
// Ein 401 kann jederzeit auftreten: 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, einmalig. Diese Datei kennt aber weder den Router noch die Meldungen
// (sie hängt von nichts ab): Sie ruft eine Funktion auf, die ihr beim
// Start übergeben wurde (onSessionExpired, siehe main.dart), die den Benutzer vergisst und
// zur Login-Seite zurückkehrt.
//
// Einige Anfragen behandeln ihr 401 selbst (das Login, GET
// /api/auth/me...): Sie sind "öffentlich" (siehe rdvmedecins_api.dart).
// =========================================================================
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../config.dart';
import 'api_error.dart';
class ApiClient {
final http.Client _client;
// was zu tun ist, wenn der Server auf eine geschützte Anfrage mit 401 antwortet
void Function() onSessionExpired = () {};
ApiClient(this._client);
// isPublic: true für die Routen, die das 401 selbst behandeln
Future<Object?> request(String method, String url, {Object? body, bool isPublic = false}) async {
final request = http.Request(method, Uri.parse('${Config.serverUrl}/api$url'));
if (body != null) {
request.headers['content-type'] = 'application/json';
request.body = jsonEncode(body);
}
final http.Response response;
try {
response = await http.Response.fromStream(await _client.send(request));
} catch (_) {
// keine Antwort: Netzwerk ausgefallen, Server gestoppt, falsche Adresse
throw const ApiError(0, 'ERRORS.SERVER_UNREACHABLE');
}
if (response.statusCode >= 400) {
final error = ApiError.fromResponse(response);
if (error.statusCode == 401 && !isPublic) {
onSessionExpired();
// der Bildschirm, der auf die Antwort wartete, zeigt AUCH diese Meldung an
throw const ApiError(401, 'ERRORS.SESSION_EXPIRED');
}
throw error;
}
return response.bodyBytes.isEmpty ? null : jsonDecode(utf8.decode(response.bodyBytes));
}
}
|
Die Datei [common/api.dart] aus den Beispielen, mit einer Neuerung: der 401-Antwort.
- Zeile 29: eine Funktion, die bei einem 401-Fehler aufgerufen wird und beim Start angegeben wird (siehe [main.dart]). Standardmäßig tut sie nichts;
- Zeile 34: [isPublic] ist ein benannter, optionaler Parameter (in geschweifte Klammern gesetzt): [request('GET', '/captcha', isPublic: true)];
- Zeilen 35–38: die Anfrage, Stück für Stück aufgebaut: Methode, Adresse, Header und JSON-Body;
- Zeilen 40–45: Die Anfrage wird gesendet. Eine Exception bedeutet hier, dass keine Antwort empfangen wurde (Netzwerk ausgefallen, Server ausgefallen, falsche Adresse). [final http.Response response;]: eine Variable, die als [final] ohne Wert deklariert wird; [Dart] prüft, dass sie vor dem Lesen einen Wert erhält – und zwar nur einmal;
- Zeilen 47–54: Eine Fehlerantwort wird zu einem [ApiError]. Ein 401 bei einer geschützten Anfrage bedeutet, dass die Sitzung abgelaufen ist: [onSessionExpired] wird aufgerufen, danach wird trotzdem ein Fehler ausgelöst (der Bildschirm, der auf die Antwort wartete, muss wissen, dass sie nicht eingetroffen ist), und zwar mit dem Schlüssel [ERRORS.SESSION_EXPIRED]: Zeigt dieser Bildschirm den Fehler an, ist es dieselbe Meldung;
- Zeile 56: Eine Antwort ohne Body (204) ergibt [null]. Wir dekodieren die Bytes nach UTF-8: Ohne den Header [charset] würde das Paket [http] den Inhalt von [response.body] als Latin-1 dekodieren, und die Akzente würden verfälscht.
11.7.3. lib/api/api_error.dart
| // =========================================================================
// lib/api/api_error.dart - EINE Klasse für alle Fehler der API
// -------------------------------------------------------------------------
// Alle Fehlerantworten des RdvMedecins-Servers haben dieselbe Form:
// { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Eine Anfrage kann aber auch ANDERS scheitern: gar keine Antwort
// (Netzwerk ausgefallen, Server gestoppt, falsche Adresse) oder eine Antwort, die
// nicht von unserem Server kommt (eine Fehlerseite eines Proxys). Wir wandeln
// all das in EINE Klasse um, ApiError, die den vom Server gesendeten
// Übersetzungsschlüssel trägt (und, falls vorhanden, dessen Parameter sowie den Fehler
// jedes Felds).
// =========================================================================
import 'dart:convert';
import 'package:http/http.dart' as http;
// "implements Exception": ein Objekt, das geworfen (throw) und gefangen (catch) werden kann
class ApiError implements Exception {
final int statusCode; // 0: der Server hat nicht geantwortet
final String key; // z. B. 'ERRORS.LOGIN_TAKEN'
final Map<String, String> params;
final Map<String, String> fields;
const ApiError(this.statusCode, this.key, {this.params = const {}, this.fields = const {}});
// eine Fehlerantwort (4xx, 5xx) -> ein ApiError
factory ApiError.fromResponse(http.Response response) {
Object? body;
try {
body = jsonDecode(utf8.decode(response.bodyBytes));
} on FormatException {
body = null; // kein JSON: Es hat nicht unser Server geantwortet
}
// das "Pattern Matching" einer Map: Hat der Body einen Schlüssel
// "key" vom Typ String, wird er in der Variablen key gespeichert
if (body case {'key': final String key}) {
final json = body as Map<String, Object?>;
return ApiError(response.statusCode, key, params: _strings(json['params']), fields: _strings(json['fields']));
}
// kein Schlüssel: Der Proxy oder das Netzwerk hat an seiner Stelle geantwortet
return ApiError(
response.statusCode,
response.statusCode >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR',
);
}
// ein JSON-Objekt { "name": "ERRORS..." } -> Map<String, String> (sonst leer)
static Map<String, String> _strings(Object? json) =>
json is Map<String, Object?> ? {for (final e in json.entries) e.key: '${e.value}'} : const {};
@override
String toString() => '$statusCode $key';
}
|
Die Datei aus Beispiel 24: Jede Anfrage, die fehlschlägt, endet mit einem [ApiError], der den Übersetzungsschlüssel der Meldung, ihre Parameter und den Fehler zu jedem Feld enthält.
11.7.4. lib/api/types.dart
| // =========================================================================
// lib/api/types.dart - die mit dem Server ausgetauschten JSON-Objekte
// -------------------------------------------------------------------------
// Die Übersetzung der im Kapitel "Der
// Server, eine Blackbox" beschriebenen API in Dart-Klassen (siehe common/types.dart der Beispiele). Jede
// Klasse liest ihr JSON mit dem Pattern Matching von Dart 3: Eine Antwort, die nicht
// die erwartete Form hat, wird erkannt, sobald sie empfangen wird.
// =========================================================================
enum Role { admin, doctor, user }
Role _role(String name) => Role.values.byName(name.toLowerCase());
Never _unexpected(String what, Object? json) => throw FormatException('unexpected $what: $json');
// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
class User {
final String login;
final String name; // angezeigter Name: "Marie PELISSIER"
final Role role;
const User(this.login, this.name, this.role);
factory User.fromJson(Object? json) => switch (json) {
{'login': final String login, 'name': final String name, 'role': final String role} => User(
login,
name,
_role(role),
),
_ => _unexpected('User', json),
};
}
// GET /api/captcha
class Captcha {
final String id;
final String svg;
const Captcha(this.id, this.svg);
factory Captcha.fromJson(Object? json) => switch (json) {
{'id': final String id, 'svg': final String svg} => Captcha(id, svg),
_ => _unexpected('Captcha', json),
};
}
// ein Titel, ein Vorname, ein Nachname
class Identity {
final String title;
final String firstName;
final String lastName;
const Identity(this.title, this.firstName, this.lastName);
factory Identity.fromJson(Object? json) => switch (json) {
{'title': final String title, 'firstName': final String firstName, 'lastName': final String lastName} => Identity(
title,
firstName,
lastName,
),
_ => _unexpected('Identity', json),
};
// "Mme Alice DURAND"
String get label => '$title $firstName $lastName';
}
// ein Arzt oder ein Client: GET /api/doctors, GET /api/clients/:id...
class Person extends Identity {
final int id;
final int version; // optimistisches Sperren: bei einer Aktualisierung zurückzusenden
final String? login; // nur für den ADMIN
const Person(this.id, this.version, super.title, super.firstName, super.lastName, [this.login]);
factory Person.fromJson(Object? json) => switch (json) {
{
'id': final int id,
'version': final int version,
'title': final String title,
'firstName': final String firstName,
'lastName': final String lastName,
} =>
Person(id, version, title, firstName, lastName, (json as Map<String, Object?>)['login'] as String?),
_ => _unexpected('Person', json),
};
static List<Person> list(Object? json) => [for (final p in json as List<Object?>) Person.fromJson(p)];
}
// ein Zeitfenster
class Slot {
final int id;
final int startHour;
final int startMinute;
final int endHour;
final int endMinute;
const Slot(this.id, this.startHour, this.startMinute, this.endHour, this.endMinute);
factory Slot.fromJson(Object? json) => switch (json) {
{'id': final int id, 'startHour': final int sh, 'startMinute': final int sm, 'endHour': final int eh, 'endMinute': final int em} =>
Slot(id, sh, sm, eh, em),
_ => _unexpected('Slot', json),
};
}
// eine Zeile des Terminkalenders mit den RECHTEN des angemeldeten Benutzers
class ScheduleSlot extends Slot {
final bool free;
final Identity? patient; // null: frei oder von einem anderen Patienten belegt
final bool mine; // der Termin des angemeldeten Patienten
final bool bookable;
final int? appointmentId; // gesetzt, wenn der Benutzer stornieren kann
const ScheduleSlot(
super.id,
super.startHour,
super.startMinute,
super.endHour,
super.endMinute,
this.free,
this.patient,
this.mine,
this.bookable,
this.appointmentId,
);
factory ScheduleSlot.fromJson(Object? json) {
final s = Slot.fromJson(json);
return switch (json) {
{
'free': final bool free,
'patient': final Object? patient,
'mine': final bool mine,
'bookable': final bool bookable,
'appointmentId': final int? appointmentId,
} =>
ScheduleSlot(
s.id,
s.startHour,
s.startMinute,
s.endHour,
s.endMinute,
free,
patient == null ? null : Identity.fromJson(patient),
mine,
bookable,
appointmentId,
),
_ => _unexpected('Slot', json),
};
}
}
// GET /api/schedule?doctorId=...&day=...
class Schedule {
final Person doctor;
final String day; // "yyyy-MM-dd"
final List<ScheduleSlot> slots;
final String? info; // Übersetzungsschlüssel (Patient, der bereits einen Termin hat)
const Schedule(this.doctor, this.day, this.slots, this.info);
factory Schedule.fromJson(Object? json) => switch (json) {
{
'doctor': final Object doctor,
'day': final String day,
'slots': final List<Object?> slots,
'info': final String? info,
} =>
Schedule(Person.fromJson(doctor), day, [for (final s in slots) ScheduleSlot.fromJson(s)], info),
_ => _unexpected('Schedule', json),
};
}
// ein Termin aus GET /api/my-area
class Appointment {
final int id;
final String day;
final Slot slot;
final Person doctor;
const Appointment(this.id, this.day, this.slot, this.doctor);
factory Appointment.fromJson(Object? json) => switch (json) {
{'id': final int id, 'day': final String day, 'slot': final Object slot, 'doctor': final Object doctor} =>
Appointment(id, day, Slot.fromJson(slot), Person.fromJson(doctor)),
_ => _unexpected('Appointment', json),
};
}
// GET /api/my-area
class MyArea {
final Identity patient;
final List<Appointment> appointments;
const MyArea(this.patient, this.appointments);
factory MyArea.fromJson(Object? json) => switch (json) {
{'patient': final Object patient, 'appointments': final List<Object?> a} => MyArea(Identity.fromJson(patient), [
for (final r in a) Appointment.fromJson(r),
]),
_ => _unexpected('Area', json),
};
}
// GET /api/my-account
class MyAccount extends Identity {
final String login;
final int version;
const MyAccount(super.title, super.firstName, super.lastName, this.login, this.version);
factory MyAccount.fromJson(Object? json) {
final i = Identity.fromJson(json);
return switch (json) {
{'login': final String login, 'version': final int version} => MyAccount(
i.title,
i.firstName,
i.lastName,
login,
version,
),
_ => _unexpected('Account', json),
};
}
}
|
Die JSON-Objekte der API als [Dart]-Klassen (siehe Beispiel 24):
- Zeile 14: eine Funktion, die nie normal terminiert (sie wirft eine Exception): Ihr Rückgabetyp ist [Never]. Sie kann daher als letzter Fall eines [switch] beliebigen Typs dienen;
- Zeilen 24–30: Filtern einer [Map]: Dieser Fall greift, wenn das JSON (mindestens) diese drei Schlüssel mit Werten dieser Typen hat, die nebenbei in Variablen gespeichert werden;
- Zeilen 69–88: ein Arzt oder ein Klient: eine [Identity] plus ein Bezeichner, eine Version (das optimistische Sperren: Sie wird bei einer Änderung zurückgesendet) und ein Login, den nur der ADMIN erhält (daher der optionale Parameter in eckigen Klammern);
- Zeilen 109–114: ein Eintrag im Terminkalender, der die vom Server berechneten RECHTE des angemeldeten Benutzers zeigt: [patient] wird nur denjenigen angezeigt, die ihn sehen dürfen, [bookable] gibt an, ob der Benutzer eine Reservierung vornehmen kann; [appointmentId] wird nur denjenigen geliefert, die stornieren können;
- Zeilen 129–151: Zuerst wird das Zeitfenster selbst ([Slot.fromJson]) gelesen, dann seine spezifischen Felder;
- Zeilen 209–213: das Konto des angemeldeten Patienten: seine Identität, sein Login und seine Version. [super.title]: Der Parameter wird unverändert an den Konstruktor der Elternklasse weitergereicht.
11.7.5. lib/api/rdvmedecins_api.dart
| // =========================================================================
// lib/api/rdvmedecins_api.dart - eine Methode pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients (ein "Repository" im
// Vokabular des Architektur-Leitfadens von Flutter): Die Bildschirme rufen
// diese typisierten Methoden auf und wissen nichts über die URLs, das Paket http oder das
// JSON. Ändert sich die API, ändert sich nur diese Datei.
// Jede Methode gibt ein Future zurück; bei einem Fehler wird es mit einem
// ApiError abgeschlossen (siehe api_client.dart).
// Die gesendeten Daten (Formulare) sind einfache Map<String, Object?>:
// Ihre Schlüssel sind die Namen der vom Server erwarteten Felder - und die
// der Fehler, die er zurücksendet (ApiError.fields).
// =========================================================================
import 'api_client.dart';
import 'types.dart';
// /api/doctors oder /api/clients: beide werden gleich behandelt
enum PersonType { doctors, clients }
typedef Data = Map<String, Object?>;
class RdvMedecinsApi {
final ApiClient _client;
RdvMedecinsApi(this._client);
Future<Object?> _get(String url, {bool isPublic = false}) => _client.request('GET', url, isPublic: isPublic);
Future<Object?> _post(String url, Object body, {bool isPublic = false}) =>
_client.request('POST', url, body: body, isPublic: isPublic);
// ------------------------------------------------ Login (öffentliche Routen)
Future<Captcha> captcha() async => Captcha.fromJson(await _get('/captcha', isPublic: true));
Future<User> me() async => User.fromJson(await _get('/auth/me', isPublic: true));
Future<User> logIn(String login, String password, String captchaId, String captcha) async =>
User.fromJson(
await _post('/auth/login', {
'login': login,
'password': password,
'captchaId': captchaId,
'captcha': captcha,
}, isPublic: true),
);
Future<void> logOut() => _post('/auth/logout', {}, isPublic: true);
// ------------------------------------------------ Kontoerstellung (öffentlich)
Future<void> registrationAccess(String captchaId, String captcha) =>
_post('/register/access', {'captchaId': captchaId, 'captcha': captcha}, isPublic: true);
Future<bool> registrationAccessStatus() async => switch (await _get('/register/access', isPublic: true)) {
{'valid': true} => true,
_ => false,
};
Future<String> register(Data data) async => switch (await _post('/register', data, isPublic: true)) {
{'login': final String login} => login,
final other => throw FormatException('Unexpected response: $other'),
};
// ------------------------------------------------ Terminkalender und Termine
// doctorId null: bei einem angemeldeten Arzt IHR Terminkalender
Future<Schedule> schedule(int? doctorId, String day) async {
final params = Uri(queryParameters: {'day': day, 'doctorId': ?doctorId?.toString()}).query;
return Schedule.fromJson(await _get('/schedule?$params'));
}
Future<void> book(String day, int slotId, int? clientId) =>
_post('/appointments', {'day': day, 'slotId': slotId, 'clientId': ?clientId});
Future<void> cancelAppointment(int appointmentId) => _client.request('DELETE', '/appointments/$appointmentId');
// ------------------------------------------------ Ärzte und Clients
Future<List<Person>> list(PersonType type) async => Person.list(await _get('/${type.name}'));
Future<Person> read(PersonType type, int id) async => Person.fromJson(await _get('/${type.name}/$id'));
Future<Person> add(PersonType type, Data data) async =>
Person.fromJson(await _post('/${type.name}', data));
Future<Person> edit(PersonType type, int id, Data data) async =>
Person.fromJson(await _client.request('PUT', '/${type.name}/$id', body: data));
Future<void> remove(PersonType type, int id) => _client.request('DELETE', '/${type.name}/$id');
// ------------------------------------------------ der Bereich des Patienten
Future<MyArea> myArea() async => MyArea.fromJson(await _get('/my-area'));
Future<MyAccount> myAccount() async => MyAccount.fromJson(await _get('/my-account'));
Future<User> editMyAccount(Data data) async =>
User.fromJson(await _client.request('PUT', '/my-account', body: data));
Future<void> deleteMyAccount(String currentPassword) =>
_client.request('DELETE', '/my-account', body: {'currentPassword': currentPassword});
}
|
Eine Methode pro Route der API: Dies ist die Klasse [RdvMedecins] aus Beispiel 24, erweitert.
- Zeile 19: [/api/doctors] und [/api/clients] werden gleich behandelt: eine Enumeration, in der der Name jedes Wertes ([PersonType.doctors.name], „doctors“) der der Route ist;
- Zeile 21: Ein Typalias: ein aussagekräftigerer Name für einen bestehenden Typ;
- Zeilen 33–47: die Anmelderouten, die öffentlich sind: Ein 401 hat dort eine eigene Bedeutung („niemand ist angemeldet“, „falsches Passwort“) und bedeutet nicht, dass die Sitzung abgelaufen ist;
- Zeile 53: Ist das Token zur Kontoerstellung gültig? Ein [switch]-Ausdruck auf die Antwort: [true] nur für [{"valid": true}];
- Zeilen 65–67: Die Adressparameter, erstellt von [Uri] (das sie kodiert). ['doctorId': ?doctorId?.toString()]: ein optionales Element einer [Map] ([Dart] 3.8): Der Schlüssel wird nur hinzugefügt, wenn der Wert nicht [null] ist. Ein angemeldeter Arzt fordert den Terminkalender ohne [doctorId]an: Der Server liefert den eigenen Terminkalender des Arztes;
- Zeile 71: ebenso wird [clientId] nur gesendet, wenn sie bekannt ist (ein Patient reserviert für sich selbst);
- Zeilen 76–86: die fünf Operationen mit Ärzten oder Klienten: [/api/${type.name}];
- Zeilen 89–97: der Bereich des Patienten. Das Löschen des Kontos sendet mit einer [DELETE]-Anfrage einen Body (das aktuelle Passwort): Das ist in HTTP erlaubt, und auch das Paket [http] erlaubt es über eine von Hand erstellte [http.Request] (siehe [api_client.dart]).
11.8. Sprachen
11.8.1. lib/i18n/translations.dart
| // =========================================================================
// lib/i18n/translations.dart - die Wörterbücher, die aktuelle Sprache
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 21. Die Wörterbücher (assets/i18n/fr.json, en.json)
// sind die der Clients in Vue.js, Angular und React: dieselben Schlüssel, dieselben
// Konventionen ({{param}}, Plurale _one / _other). Der Server sendet nur
// SCHLÜSSEL zurück ("ERRORS.LOGIN_TAKEN"): Hier werden sie zu
// Text, in der vom Benutzer gewählten Sprache.
// - t('KEY', {'param': value}) : der Text der aktuellen Sprache;
// - changeLanguage('fr') : lädt das andere Wörterbuch, benachrichtigt
// die Bildschirme (ChangeNotifier), speichert
// die Wahl auf dem Gerät.
// =========================================================================
import 'dart:convert';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:intl/intl.dart';
import 'package:shared_preferences/shared_preferences.dart';
const languages = ['fr', 'en'];
class Translations extends ChangeNotifier {
final SharedPreferences? _storage;
String _language = 'en';
Map<String, Object?> _dictionary = {};
Translations([this._storage]);
String get language => _language;
// die Anfangssprache: die auf dem Gerät gespeicherte, sonst die des
// Telefons (falls bekannt), sonst Englisch
Future<void> start() async {
final stored = _storage?.getString('rdvmedecins.language');
final device = WidgetsBinding.instance.platformDispatcher.locale.languageCode;
await changeLanguage(stored ?? (languages.contains(device) ? device : 'en'));
}
Future<void> changeLanguage(String language) async {
// rootBundle: die mit der Anwendung ausgelieferten Dateien (Abschnitt assets der pubspec)
final json = await rootBundle.loadString('assets/i18n/$language.json');
_dictionary = jsonDecode(json) as Map<String, Object?>;
_language = language;
await _storage?.setString('rdvmedecins.language', language);
notifyListeners();
}
// "HOME.HELLO" -> dictionary['HOME']['HELLO']; null, falls nicht vorhanden
String? _find(String key) {
Object? node = _dictionary;
for (final part in key.split('.')) {
node = node is Map<String, Object?> ? node[part] : null;
}
return node is String ? node : null;
}
String t(String key, [Map<String, Object?> params = const {}]) {
String? text;
final count = params['count'];
if (count is int) {
// Intl.pluralLogic: die Pluralform nach den Regeln der Sprache
text = Intl.pluralLogic(
count,
locale: _language,
zero: _find('${key}_zero'),
one: _find('${key}_one'),
other: _find('${key}_other'),
);
}
text ??= _find(key);
// ein unbekannter Schlüssel wird unverändert angezeigt: Wir sehen sofort, was fehlt
if (text == null) return key;
// {{name}} -> der Wert des Parameters name
return text.replaceAllMapped(RegExp(r'\{\{(\w+)\}\}'), (m) => '${params[m[1]] ?? m[0]}');
}
}
|
Die Klasse [Translations] aus Beispiel 21, vereinfacht: Die Wörterbücher heißen immer gleich ([assets/i18n/fr.json]).
- Zeilen 35–38: die Anfangssprache: die bei einer früheren Nutzung gewählte, andernfalls die Sprache des Smartphones, wenn die App sie kennt, andernfalls Englisch. [platformDispatcher.locale]: die Systemsprache;
- Zeilen 59–76: die Übersetzung eines Schlüssels, einschließlich Pluralen ([_zero], [_one], [_other]) und Parametern ([{{name}}]), nach den Konventionen von [i18next], die dieselben sind wie in den Wörterbüchern der anderen Clients.
11.8.2. Die Wörterbücher
Die Wörterbücher sind die des [React]-Clients, ergänzt um einige Schlüssel, die für die mobile App spezifisch sind (das Menü „Mein Konto“, „Tag wählen“ usw.). Der Anfang des französischen Wörterbuchs:
| {
"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"
},
|
Eine Datei pro Sprache, in jeder dieselben Schlüssel; eine Schlüsselgruppe pro Bildschirm; die Schlüssel [ERRORS.*] sind die vom Server zurückgegebenen.
11.9. Der gemeinsame Zustand
Drei [ChangeNotifier]-Objekte , die der gesamten Anwendung durch [main.dart] bereitgestellt werden.
11.9.1. lib/state/session.dart
| // =========================================================================
// lib/state/session.dart - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der angemeldete Benutzer (oder null) in einem ChangeNotifier, der der gesamten
// Anwendung bereitgestellt wird (provider, siehe Beispiel 20): lesbar für die Bildschirme UND für den
// Router, der ihn abhört, um seine Guards neu auszuwerten (refreshListenable).
//
// Das JWT-Token selbst ist NICHT hier: Es liegt in einem Cookie (im Web vom
// Browser verwaltet, auf dem Smartphone von CookieClient). Die
// Sitzung behält nur die BESCHREIBUNG des Benutzers ({ login, name, role }).
//
// Wenn die Anwendung startet, ist die Sitzung leer: check() fragt
// den Server nur ein einziges Mal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================
import 'package:flutter/foundation.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
class Session extends ChangeNotifier {
final RdvMedecinsApi _api;
User? _user;
// true nach einem GEWOLLTEN Logout (Button, Kontolöschung); false
// nach einer abgelaufenen Sitzung. Der Router berücksichtigt es (siehe router.dart)
bool _voluntaryLogout = false;
// wurde dem Server die Frage "Wer ist angemeldet?" bereits gestellt?
Future<void>? _checking;
Session(this._api);
User? get user => _user;
bool get voluntaryLogout => _voluntaryLogout;
// fragt den Server nur beim ersten Mal (das Future wird behalten)
Future<void> check() => _checking ??= _api.me().then(
(u) => _change(u),
onError: (Object _) => _change(null), // 401: niemand; oder Server nicht erreichbar
);
Future<void> logIn(String login, String password, String captchaId, String captcha) async {
_change(await _api.logIn(login, password, captchaId, captcha));
}
// der Benutzer hat seinen Namen oder sein Login geändert (PUT /api/my-account)
void update(User u) => _change(u);
Future<void> logOut() async {
try {
await _api.logOut();
} finally {
forget(voluntary: true);
}
}
// ohne den Server etwas zu fragen: Sitzung abgelaufen, Konto gelöscht
void forget({bool voluntary = false}) => _change(null, voluntary: voluntary);
// notifyListeners: Der Router (refreshListenable) wertet seine Guards neu aus und
// verlässt von selbst einen Bildschirm, den der neue Benutzer nicht sehen darf
void _change(User? u, {bool voluntary = false}) {
_user = u;
_voluntaryLogout = voluntary;
notifyListeners();
}
}
// was wir aus dem Benutzer ableiten: Extensions ("Getter", die zu User? hinzugefügt werden)
extension Rights on User? {
bool get isAdmin => this?.role == Role.admin;
bool get isPatient => this?.role == Role.user;
// ADMIN und DOCTOR: Termine beliebiger Patienten buchen und stornieren
bool get isManager => this?.role == Role.admin || this?.role == Role.doctor;
// die Startseite jeder Rolle, direkt nach dem Login
String get homePage => isPatient ? '/my-area' : '/schedule';
}
|
Wer ist angemeldet? Die Sitzung speichert die BESCHREIBUNG des Benutzers (Login, Name, Rolle), nicht das Token, das im Cookie des Benutzers verbleibt.
- Zeilen 36–38: Die Frage „Wer ist angemeldet?“ wird nur EINMAL, beim Start, an den Server gesendet ([GET /api/auth/me]): [??=] weist das [Future] nur zu, wenn [_checking] [null] ist. Spätere Aufrufe liefern dasselbe [Future], das bereits abgeschlossen ist: Der Router kann [check()] vor jeder Navigation kostenlos aufrufen. Enthält der beim Start gespeicherte Cookie ein noch gültiges Token, bleibt der Benutzer angemeldet;
- Zeilen 41–42: die Anmeldung: Lehnt der Server ab, [_api.logIn] wirft einen [ApiError], und [_change] wird nicht aufgerufen;
- Zeilen 48–52: die Abmeldung: Der Benutzer wird vergessen, auch wenn der Server nicht antwortet ([finally]);
- Zeilen 61–64: Alle Änderungen laufen hier durch und benachrichtigen die Listener: die Bildschirme, die den Benutzer anzeigen (das Layout), den Cache (der geleert wird) und den Router (der seine Guards neu auswertet). [_voluntaryLogout] unterscheidet zwischen einer gewollten Abmeldung und einer abgelaufenen Sitzung (siehe [router.dart]);
- Zeilen 69–75: Eine Extension fügt einem bestehenden Typ Getter hinzu, hier [User?]: [session.user.isAdmin] ist [false] , wenn niemand angemeldet ist, ohne zuvor auf [null] ([this?.role]) zu prüfen.
11.9.2. lib/state/messages.dart
| // =========================================================================
// lib/state/messages.dart - 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), immer sichtbar.
// Eine Meldung ist ein Übersetzungs-SCHLÜ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. Der Router ruft newPage() am
// Ende jeder Navigation auf (siehe router.dart).
// =========================================================================
import 'package:flutter/foundation.dart';
import '../api/api_error.dart';
typedef Message = ({String key, Map<String, String> params});
class Messages extends ChangeNotifier {
Message? success;
Message? error;
// die auf dem nächsten Bildschirm anzuzeigenden Meldungen
Message? _pendingSuccess;
Message? _pendingError;
void showSuccess(String key, [Map<String, String> params = const {}]) {
success = (key: key, params: params);
error = null;
notifyListeners();
}
void showError(String key, [Map<String, String> params = const {}]) {
error = (key: key, params: params);
success = null;
notifyListeners();
}
// ein ApiError -> die Meldung des Bildschirms; jeder andere Fehler ist ein
// Fehler des Clients, den wir weiterlaufen lassen
void showApiError(Object e) {
if (e is! ApiError) throw e;
showError(e.key, e.params);
}
void clear() {
success = null;
error = null;
notifyListeners();
}
// für den NÄCHSTEN Bildschirm
void flash({bool success = true, required String key, Map<String, String> params = const {}}) {
if (success) {
_pendingSuccess = (key: key, params: params);
} else {
_pendingError = (key: key, params: params);
}
}
// ein neuer Bildschirm: Die Meldungen des vorherigen verschwinden, die Flash-Meldungen
// erscheinen
void newPage() {
success = _pendingSuccess;
error = _pendingError;
_pendingSuccess = null;
_pendingError = null;
notifyListeners();
}
}
|
Meldungen der Anwendung: eine Erfolgsmeldung oben auf dem Bildschirm, eine Fehlermeldung unten (siehe [layout.dart]).
- Zeile 21: Eine Meldung besteht aus einem Übersetzungsschlüssel und seinen Parametern (ein einziger Record). Sie wird erst bei der Anzeige übersetzt: Ein Sprachwechsel übersetzt die angezeigten Meldungen neu;
- Zeilen 44–46: Ein [ApiError] wird zur Fehlermeldung des Bildschirms. Jede andere Exception ist ein clientseitiges Problem: Wir werfen sie erneut, damit sie während der Entwicklung in der Konsole erscheint, statt sie zu verbergen;
- Zeilen 56–60: eine Meldung für den NÄCHSTEN Bildschirm: Eine Aktion, die mit einem Bildschirmwechsel endet (eine Reservierung, ein Hinzufügen usw.), legt ihre Meldung hier ab;
- Zeilen 66–71: wird bei jeder Adressänderung aufgerufen (siehe [main.dart]): Die Meldungen des vorherigen Bildschirms verschwinden, und die Flash-Meldungen erscheinen.
11.9.3. lib/state/cache.dart
| // =========================================================================
// lib/state/cache.dart - die bereits vom Server gelesenen Daten
// -------------------------------------------------------------------------
// Die Liste der Ärzte ändert sich fast nie: Sie muss nicht bei jedem Besuch
// des Terminkalenders neu gelesen werden. Der Cache behält das Future jedes Lesevorgangs
// unter einem SCHLÜSSEL ('doctors', 'schedule/1/2026-10-05'...):
//
// cache.read('doctors', () => api.list(PersonType.doctors))
//
// gibt das bereits behaltene Future zurück oder startet das Lesen und behält es.
// Nach einer Änderung machen wir die betroffenen Schlüssel UNGÜLTIG (sie werden
// bei der nächsten Anfrage neu gelesen): cache.invalidate('schedule').
// Ein fehlgeschlagenes Lesen wird nicht behalten: Das nächste versucht es erneut.
// Der Cache ist ein ChangeNotifier: invalidate() benachrichtigt seine Listener. Ein
// noch lebender Bildschirm (auch wenn er unter einem anderen auf dem Stack verborgen ist, wie
// der Terminkalender unter seinem Buchungsdialog) kann so seine Daten neu lesen.
// Das ist in wenigen Zeilen das, was die Bibliothek TanStack Query des
// React-Clients tut.
// =========================================================================
import 'package:flutter/foundation.dart';
class Cache extends ChangeNotifier {
final Map<String, Future<Object?>> _futures = {};
Future<T> read<T>(String key, Future<T> Function() load) {
final future = _futures.putIfAbsent(key, () {
final f = load();
// bei einem Fehler vergessen wir dieses Future (die nächste Anfrage versucht es erneut)
f.then((_) {}, onError: (Object _) => _futures.remove(key));
return f;
});
return future.then((v) => v as T);
}
// vergisst alle Schlüssel, die mit prefix beginnen, und benachrichtigt die Bildschirme
void invalidate(String prefix) {
_futures.removeWhere((key, _) => key.startsWith(prefix));
notifyListeners();
}
// Benutzerwechsel: Wir vergessen alles, OHNE zu benachrichtigen (die Bildschirme des
// vorherigen Benutzers verschwinden gleich, sie dürfen nichts neu lesen)
void clear() => _futures.clear();
}
|
Bereits vom Server gelesene Daten: das Äquivalent, in wenigen Zeilen, von [TanStack Query] im [React]-Client.
- Zeile 24: Der Cache speichert [Future], keine tatsächlichen Werte: Zwei Bildschirme, die dieselben Daten anfordern, solange sie unterwegs sind, erhalten DASSELBE [Future], und es wird nur eine einzige Anfrage gesendet;
- Zeilen 26–33: Eine generische Methode: [read<List<Person>>(...)] liefert ein [Future<List<Person>>] (der Typ [T] wird meist aus der Funktion [load] abgeleitet). [putIfAbsent]: der Wert des Schlüssels oder, fehlt der Schlüssel, das Ergebnis der Funktion, unter diesem Schlüssel gespeichert. Ein fehlgeschlagenes Lesen wird ignoriert: Die nächste Anfrage versucht es erneut;
- Zeilen 37–39: Nach einer Änderung werden die betroffenen Schlüssel verworfen und die Bildschirme benachrichtigt. Der Terminkalender-Bildschirm hört darauf: Nach einer Reservierung lädt er sich neu, auch wenn er hinter dem Buchungsfenster verdeckt ist;
- Zeile 44: Wechselt der Benutzer, wird alles geleert, ohne jemanden zu benachrichtigen: Die Bildschirme des vorherigen Benutzers verschwinden; es gibt für sie nichts neu zu laden.
| // =========================================================================
// lib/formatting.dart - 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).
// =========================================================================
import 'package:intl/intl.dart';
import 'api/types.dart';
String _twoDigits(int n) => n.toString().padLeft(2, '0');
// "8:05" statt "8:5"
String time(int h, int m) => '$h:${_twoDigits(m)}';
// "8:00 - 8:20"
String timeRange(Slot s) => '${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}';
// ein Datum -> "yyyy-MM-dd" (das Format der API)
String toDay(DateTime d) => '${d.year}-${_twoDigits(d.month)}-${_twoDigits(d.day)}';
String today() => toDay(DateTime.now());
// true, wenn day ein existierendes Datum im Format yyyy-MM-dd ist
bool isValidDate(String day) {
if (!RegExp(r'^\d{4}-\d{2}-\d{2}$').hasMatch(day)) return false;
final d = DateTime.tryParse(day);
return d != null && toDay(d) == day; // 2026-02-30 -> 2026-03-02: abgelehnt
}
// "Monday, October 5, 2026" / "lundi 5 octobre 2026"
String longDate(String day, String language) => DateFormat.yMMMMEEEEd(language).format(DateTime.parse(day));
|
Formatierung der Rohdaten des Servers (siehe Beispiel 09):
- Zeile 22: ein [DateTime] im API-Format („2026-10-05“);
- Zeilen 27–30: Ist das Datum in der Adresse gültig? [DateTime.tryParse] akzeptiert „2026-02-30“ (2. März): Wir prüfen, dass dieselbe Zeichenkette vorliegt;
- Zeile 34: „Monday, October 5, 2026“ oder „lundi 5 octobre 2026“, je nach Sprache ([DateFormat.yMMMMEEEEd] abgeleitet aus [intl]).
11.11. Der Router
11.11.1. lib/router.dart
| // =========================================================================
// lib/router.dart - die Bildschirme der Anwendung und ihre Zugriffsrechte
// -------------------------------------------------------------------------
// Die GLEICHEN Adressen wie bei den anderen Clients (/login, /schedule, /doctors,
// /my-area...). Im Web werden sie in der Adressleiste angezeigt;
// auf dem Smartphone bleiben sie unsichtbar, gliedern die Anwendung aber
// genauso (ebenso den Stack der Bildschirme des Zurück-Buttons).
//
// Alle Bildschirme liegen in einer ShellRoute, deren Widget AppLayout sie
// zwischen der oberen Leiste und dem Fehlerbereich anzeigt.
//
// Die GUARDS: Die Funktion redirect des GoRouter wird vor JEDER
// Navigation aufgerufen. Sie kann asynchron sein: Beim ersten Mal (Start
// der Anwendung, F5 im Web) wartet sie auf die Antwort des Servers auf die
// Frage "Wer ist angemeldet?" (session.check()). Dann prüft sie die
// Rechte des angeforderten Bildschirms (rightsOf) und leitet bei Bedarf um.
// ERINNERUNG: Diese Prüfungen sind nur eine ERLEICHTERUNG (keinen nutzlosen
// Bildschirm anzeigen). Der Schutz der Daten wird vom Server gewährleistet, der
// bei JEDER Anfrage das Token und die Rolle erneut prüft.
// =========================================================================
import 'package:go_router/go_router.dart';
import 'api/rdvmedecins_api.dart';
import 'api/types.dart';
import 'state/messages.dart';
import 'state/session.dart';
import 'pages/schedule.dart';
import 'pages/login.dart';
import 'pages/patient_area.dart';
import 'pages/register.dart';
import 'pages/my_account.dart';
import 'pages/error_page.dart';
import 'pages/person_form.dart';
import 'pages/persons.dart';
import 'widgets/layout.dart';
// die Zugriffsrechte eines Bildschirms: öffentlich (ohne Login) oder einigen
// Rollen vorbehalten (null: alle angemeldeten Rollen)
typedef Rights = ({bool public, Set<Role>? roles});
Rights rightsOf(String path) => switch (path) {
'/login' || '/register' => (public: true, roles: null),
_ when path.startsWith('/doctors') || path.startsWith('/clients') => (public: false, roles: {Role.admin}),
'/my-area' || '/my-account' => (public: false, roles: {Role.user}),
'/schedule' || '/forbidden' || '/' => (public: false, roles: null),
_ => (public: true, roles: null), // unbekannte Adresse: die 404-Seite, für alle
};
// nur ein INTERNER Pfad ("/doctors"): niemals "//other-site.com"
String? internalPath(String? r) => r != null && r.startsWith('/') && !r.startsWith('//') ? r : null;
// "3" -> 3; "", "abc", "-2", fehlend (null) -> null
int? positiveInteger(String? value) {
final n = int.tryParse(value ?? '');
return n != null && n > 0 ? n : null;
}
GoRouter createRouter(Session session, Messages messages, RdvMedecinsApi api) {
// die drei Verwaltungsbildschirme der Ärzte ODER der Clients (ADMIN)
List<GoRoute> personRoutes(PersonType type) => [
GoRoute(
path: '/${type.name}',
builder: (_, _) => PersonsPage(type: type),
),
GoRoute(
path: '/${type.name}/add',
builder: (_, _) => PersonFormPage(type: type),
),
GoRoute(
path: '/${type.name}/:id/edit',
builder: (_, state) {
final id = positiveInteger(state.pathParameters['id']);
// /doctors/abc/edit: Diese Adresse existiert nicht
return id == null ? const ErrorPage(code: 404) : PersonFormPage(type: type, id: id);
},
),
];
return GoRouter(
initialLocation: '/login',
// die Sitzung ändert sich (Login, Logout, Ablauf): Die Guards
// werden für den aktuellen Bildschirm neu ausgewertet
refreshListenable: session,
redirect: (context, state) async {
await session.check();
final user = session.user;
final path = state.uri.path;
final rights = rightsOf(path);
if (rights.public) {
// angemeldet: Der Login-Bildschirm ergibt keinen Sinn mehr. Hier verlassen wir ihn,
// direkt nach dem Login: Die Sitzung hat sich geändert, der Router
// (der sie abhört) wertet seine Guards neu aus. Wir gehen zu dem vor dem
// Login angeforderten Bildschirm (?redirect=...), sonst zur Startseite der Rolle
if (path == '/login' && user != null) {
return internalPath(state.uri.queryParameters['redirect']) ?? user.homePage;
}
return null;
}
if (user == null) {
// gewolltes Logout: einfach der Login-Bildschirm
if (session.voluntaryLogout) return '/login';
// abgelaufene Sitzung, ohne Anmeldung geöffnete Adresse: Wir merken uns den
// angeforderten Bildschirm, um nach dem Login dorthin zurückzukehren
return Uri(path: '/login', queryParameters: {'redirect': state.uri.toString()}).toString();
}
if (path == '/') return user.homePage;
if (rights.roles != null && !rights.roles!.contains(user.role)) return '/forbidden';
return null;
},
routes: [
ShellRoute(
builder: (context, state, child) => AppLayout(child: child),
routes: [
GoRoute(path: '/', builder: (_, _) => const ErrorPage(code: 404)), // (oben umgeleitet)
GoRoute(
path: '/login',
builder: (_, state) {
// das Login der Adresse: höchstens 30 Zeichen
final login = state.uri.queryParameters['login'] ?? '';
return LoginPage(login: login.length > 30 ? login.substring(0, 30) : login);
},
),
GoRoute(
path: '/schedule',
builder: (_, state) => SchedulePage(
doctorId: positiveInteger(state.uri.queryParameters['doctorId']),
day: state.uri.queryParameters['day'],
book: positiveInteger(state.uri.queryParameters['book']),
),
),
...personRoutes(PersonType.doctors),
...personRoutes(PersonType.clients),
GoRoute(
path: '/register',
// ein für diese Route SPEZIFISCHER Guard: Ohne Berechtigung (auf dem Login-Bildschirm gelöstes
// Captcha) zurück zum Login-Bildschirm
redirect: (context, state) async {
final valid = await api.registrationAccessStatus().catchError((_) => false);
if (valid) return null;
messages.flash(success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
return '/login';
},
builder: (_, _) => const RegisterPage(),
),
GoRoute(path: '/my-area', builder: (_, _) => const PatientAreaPage()),
GoRoute(path: '/my-account', builder: (_, _) => const MyAccountPage()),
GoRoute(path: '/forbidden', builder: (_, _) => const ErrorPage(code: 403)),
],
),
],
// eine Adresse, die keine Route beschreibt: die 404-Seite im Layout
errorBuilder: (context, state) => const AppLayout(child: ErrorPage(code: 404)),
);
}
|
Die Bildschirme der Anwendung, ihre Adressen und ihre Zugriffsrechte (siehe Beispiele 17 und 18).
- Zeile 40: die Zugriffsrechte eines Bildschirms: öffentlich oder auf bestimmte Rollen beschränkt ([null]: alle Rollen);
- Zeilen 42–47: die Berechtigungen für jede Adresse, an EINER einzigen Stelle: ein [switch]-Ausdruck auf Zeichenketten. ['/login' || '/register']: ein „Oder“-Muster; [_ when ...]: ein „Alles“-Muster mit einer Bedingung (ein Guard);
- Zeile 51: Die Adresse [?redirect=] wird nur befolgt, wenn es sich um einen INTERNEN Pfad handelt: Im Web darf eine Adresse [/login?redirect=//pirate-site.com] , die per E-Mail verschickt wurde, den Benutzer nach der Anmeldung nicht woandershin führen;
- Zeilen 54–56: Die Parameter einer Adresse sind Zeichenketten, die (im Web) von jedem beliebigen Absender stammen können: „abc“ oder „-2“ werden zu [null];
- Zeilen 61–78: eine lokale Funktion, die die drei Routen für die Ärzte ODER die Klienten erzeugt: [/doctors], [/doctors/add], [/doctors/:id/edit]. [:id]: ein Pfadparameter, gelesen mit [state.pathParameters['id']];
- Zeile 81: der Startbildschirm auf dem Smartphone (im Web ist es die eingegebene Adresse);
- Zeile 84: Der Router überwacht die Sitzung: Bei jeder Änderung (Anmeldung, Abmeldung, Ablauf) wertet er seine Guards für den aktuellen Bildschirm neu aus und wechselt bei Bedarf den Bildschirm;
- Zeilen 85–109: DER Guard, der vor jeder Navigation aufgerufen wird:
- Zeile 86: Beim ersten Mal warten wir auf die Antwort des Servers auf die Frage „Wer ist angemeldet?“; danach kostet dieser Aufruf nichts;
- Zeilen 90–98: Ein öffentlicher Bildschirm ist für alle zugänglich; ein angemeldeter Benutzer hat jedoch auf dem Anmeldebildschirm nichts verloren: Er gelangt zu dem Bildschirm, den er vor der Anmeldung angefordert hatte, oder zum Startbildschirm seiner Rolle. So verlässt die Anwendung den Anmeldebildschirm nach erfolgreicher Anmeldung: Der Anmeldebildschirm selbst muss nicht navigieren;
- Zeilen 100–105: Niemand ist angemeldet: weiter zum Anmeldebildschirm. Nach Ablauf einer Sitzung oder wenn eine geschützte URL (im Web) direkt geöffnet wurde, wird der angeforderte Bildschirm ([?redirect=]) gespeichert, damit der Benutzer nach der Anmeldung dorthin zurückkehren kann; nach einer absichtlichen Abmeldung wird er nicht gespeichert;
- Zeilen 107–108: [/] führt zur Startseite der Rolle; eine unzureichende Rolle führt zu einer 403-Seite;
- Zeilen 112–113: Alle Bildschirme werden innerhalb des Layouts angezeigt (Titelleiste, Menü, Meldungen);
- Zeilen 117–121: [/login?login=jbernard] (nach dem Anlegen eines Kontos) füllt das Anmeldefeld vor;
- Zeilen 125–129: die drei Kalenderparameter, aus der URL gelesen; der gesamte Zustand des Bildschirms ist dort enthalten (siehe [schedule.dart]);
- Zeilen 135–142: ein Guard, der SPEZIFISCH für eine Route gilt: Das Anlegen eines Kontos erfordert einen Passierschein, den der Server ausstellt, sobald das CAPTCHA eingegeben wurde ([POST /api/register/access], siehe Anmeldebildschirm). Ohne ihn werden Sie mit einer Meldung zum Anmeldebildschirm umgeleitet;
- Zeile 153: eine Adresse, die keiner Route zugeordnet ist: die 404-Seite, innerhalb des Layouts.
Diese Sicherungen sind lediglich eine Formalität: Sie verhindern, dass ein nutzloser Bildschirm angezeigt wird. Der Datenschutz wird vom Server gewährleistet, der bei jeder Anfrage das Token und die Rolle erneut prüft.
| // =========================================================================
// lib/widgets/layout.dart - das allen Bildschirmen GEMEINSAME Layout
// -------------------------------------------------------------------------
// Das Widget der ShellRoute des Routers (siehe router.dart):
// - die obere Leiste: Titel, Sprache (FR / EN), Logout;
// - das seitliche Menü ("Drawer", Drawer), geöffnet über den Button ☰: die
// für die Rolle des Benutzers erlaubten Bildschirme. "Doctors" und "Patients"
// erscheinen nur für den ADMIN: eine bloße Anzeigeerleichterung, der
// eigentliche Schutz liegt beim Server;
// - eine Erfolgsmeldung OBEN;
// - der aktuelle Bildschirm (child);
// - der Fehlerbereich UNTEN.
// Auf einem großen Bildschirm (Web, Tablet) wird das Menü dauerhaft
// links angezeigt: eine NavigationRail statt des Drawers.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../state/messages.dart';
import '../state/session.dart';
import '../i18n/translations.dart';
// ein Menüeintrag: Pfad, Schlüssel des Labels, Icon
typedef MenuEntry = ({String path, String key, IconData icon});
List<MenuEntry> menuEntries(Session session) {
final u = session.user;
if (u == null) return const [];
return [
if (u.isPatient) (path: '/my-area', key: 'APP.MENU_MY_AREA', icon: Icons.home),
(path: '/schedule', key: 'APP.MENU_SCHEDULE', icon: Icons.calendar_month),
if (u.isAdmin) ...[
(path: '/doctors', key: 'APP.MENU_DOCTORS', icon: Icons.medical_services),
(path: '/clients', key: 'APP.MENU_PATIENTS', icon: Icons.people),
],
if (u.isPatient) (path: '/my-account', key: 'APP.MENU_ACCOUNT', icon: Icons.manage_accounts),
];
}
class AppLayout extends StatelessWidget {
final Widget child;
const AppLayout({super.key, required this.child});
@override
Widget build(BuildContext context) {
final translations = context.watch<Translations>();
final t = translations.t;
final session = context.watch<Session>();
final u = session.user;
final entries = menuEntries(session);
// die aktuelle Adresse, wie der Router sie kennt
final path = GoRouter.of(context).routerDelegate.currentConfiguration.uri.path;
final active = entries.indexWhere((e) => path.startsWith(e.path));
// MediaQuery: die Abmessungen des Bildschirms; ab 800 Punkten ein großer Bildschirm
final largeScreen = MediaQuery.sizeOf(context).width >= 800;
// die Sitzung wird leer; der Router, der sie abhört, zeigt den Login-Bildschirm an
Future<void> logOut() => session.logOut().catchError((_) {}); // auch wenn der Server nicht antwortet
final content = Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
const _SuccessMessage(),
Expanded(child: child),
const _ErrorPanel(),
],
);
return Scaffold(
appBar: AppBar(
title: Text(t('APP.TITLE')),
backgroundColor: Theme.of(context).colorScheme.primary,
foregroundColor: Theme.of(context).colorScheme.onPrimary,
actions: [
// FR / EN: keine Anfrage an den Server, der Bildschirm wird sofort neu übersetzt
PopupMenuButton<String>(
tooltip: t('APP.LANGUAGE'),
// der Text in der Farbe der Icons der Leiste (onPrimary)
icon: Text(
translations.language.toUpperCase(),
style: TextStyle(fontWeight: FontWeight.bold, color: Theme.of(context).colorScheme.onPrimary),
),
onSelected: translations.changeLanguage,
itemBuilder: (_) => [for (final l in languages) PopupMenuItem(value: l, child: Text(l.toUpperCase()))],
),
if (u != null) IconButton(tooltip: t('APP.LOGOUT'), icon: const Icon(Icons.logout), onPressed: logOut),
],
),
// der Drawer: nur wenn angemeldet und nur auf einem kleinen Bildschirm
drawer: u == null || largeScreen
? null
: NavigationDrawer(
selectedIndex: active < 0 ? null : active,
onDestinationSelected: (i) {
Navigator.pop(context); // schließt den Drawer
context.go(entries[i].path);
},
children: [
// der Kopfbereich: wer angemeldet ist
Padding(
padding: const EdgeInsets.fromLTRB(28, 16, 16, 10),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(u.name, style: Theme.of(context).textTheme.titleMedium),
Chip(label: Text(u.role.name.toUpperCase())),
],
),
),
for (final e in entries) NavigationDrawerDestination(icon: Icon(e.icon), label: Text(t(e.key))),
],
),
body: u == null || !largeScreen
? content
: Row(
children: [
NavigationRail(
selectedIndex: active < 0 ? null : active,
labelType: NavigationRailLabelType.all,
onDestinationSelected: (i) => context.go(entries[i].path),
destinations: [
for (final e in entries) NavigationRailDestination(icon: Icon(e.icon), label: Text(t(e.key))),
],
),
const VerticalDivider(width: 1),
Expanded(child: content),
],
),
);
}
}
// die Erfolgsmeldung oben
class _SuccessMessage extends StatelessWidget {
const _SuccessMessage();
@override
Widget build(BuildContext context) {
final success = context.watch<Messages>().success;
if (success == null) return const SizedBox.shrink();
final t = context.watch<Translations>().t;
return Material(
color: Colors.green.shade50,
child: ListTile(
leading: Icon(Icons.check_circle, color: Colors.green.shade700),
title: Text(t(success.key, success.params), style: TextStyle(color: Colors.green.shade900)),
trailing: IconButton(icon: const Icon(Icons.close), onPressed: context.read<Messages>().clear),
),
);
}
}
// der Fehlerbereich unten: immer sichtbar, auch wenn der Bildschirm scrollt
class _ErrorPanel extends StatelessWidget {
const _ErrorPanel();
@override
Widget build(BuildContext context) {
final error = context.watch<Messages>().error;
if (error == null) return const SizedBox.shrink();
final t = context.watch<Translations>().t;
return Material(
color: const Color(0xFFF8D7DA),
// SafeArea: oberhalb der Navigationsleiste des Smartphones
child: SafeArea(
top: false,
child: ListTile(
leading: Icon(Icons.error, color: Colors.red.shade800),
title: Text(t(error.key, error.params), style: TextStyle(color: Colors.red.shade900)),
trailing: IconButton(icon: const Icon(Icons.close), onPressed: context.read<Messages>().clear),
),
),
);
}
}
|
Das Layout, das Widget der [ShellRoute]: das Element, das alle Bildschirme umgibt.
- Zeile 26: ein Menüeintrag: ein Record;
- Zeilen 28–38: für die Rolle des Benutzers zulässige Einträge, über ein [if] in einer Liste (Beispiel 03). [...[...]]: der Spread-Operator fügt mehrere Elemente auf einmal ein;
- Zeile 55: die aktuelle Adresse, um den aktiven Menüeintrag zu markieren;
- Zeile 58: die Bildschirmbreite in Punkten. Ab 800 Punkten (Web, Tablet im Querformat) wird das Menü dauerhaft angezeigt;
- Zeile 61: Abmeldung – die Sitzung wird gelöscht, und der Router, der darauf lauscht, zeigt den Anmeldebildschirm an. [catchError]: Selbst wenn der Server nicht antwortet, gilt der Benutzer als abgemeldet;
- Zeilen 63–68: die Erfolgsmeldung oben, der Bildschirm in der Mitte ([Expanded]: der gesamte verbleibende Platz), der Fehler unten;
- Zeilen 73–89: die Titelleiste: der Titel, das Sprachmenü ([PopupMenuButton]: eine Schaltfläche, die eine Liste öffnet; ihr Symbol ist hier ein Text, „FR“ oder „EN“), die Abmeldeschaltfläche;
- Zeilen 93–113: auf einem kleinen Bildschirm eine Schublade ([NavigationDrawer]), die sich über die Schaltfläche ☰ öffnet, die [Scaffold] automatisch zur Titelleiste hinzufügt. Das Antippen eines Eintrags schließt die Schublade ([Navigator.pop]) und ändert die URL;
- Zeilen 116–129: Auf einem großen Bildschirm eine [NavigationRail]: das Menü, in einer Spalte links vom Inhalt angeordnet;
- Zeilen 137–154: die Erfolgsmeldung. [context.watch<Messages>()]: Das Widget wird bei jeder Änderung der Meldungen neu erstellt; wenn keine Meldungen vorhanden sind, nimmt es keinen Platz ein ([SizedBox.shrink]);
- Zeilen 168–169: Der Fehlerbereich befindet sich am unteren Bildschirmrand: [SafeArea] hält ihn von der Navigationsleiste des Smartphones fern (den Schaltflächen oder der Gestenleiste von [Android]).
11.12.2. lib/widgets/page_title.dart
| // =========================================================================
// lib/widgets/page_title.dart - der Titel des Bildschirms, übersetzt
// -------------------------------------------------------------------------
// Im Web: der Titel des Tabs; auf Android: der Name der Anwendung
// in der Liste der zuletzt verwendeten Anwendungen. "Schedule - RdvMedecins"
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../i18n/translations.dart';
class PageTitle extends StatelessWidget {
final String titleKey;
final Widget child;
const PageTitle({super.key, required this.titleKey, required this.child});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return Title(title: '${t(titleKey)} - ${t('APP.TITLE')}', color: Theme.of(context).colorScheme.primary, child: child);
}
}
|
Der übersetzte Titel des Bildschirms ([Title], siehe Beispiel 02): der Tab-Titel im Web, der App-Name in der Liste der zuletzt verwendeten Apps unter [Android].
| // =========================================================================
// lib/widgets/form_submit.dart - Senden eines Formulars an den Server
// -------------------------------------------------------------------------
// Alle Formulare der Anwendung folgen demselben Muster wie
// Beispiel 25: Keine Regel wird auf dem Smartphone geprüft (sie leben
// nur an EINER Stelle, dem Server), und im Fall einer Ablehnung:
// - wird der Fehler jedes Felds (ApiError.fields) unter dem Feld angezeigt;
// - wird die allgemeine Meldung (ApiError.key) unten auf dem Bildschirm angezeigt.
// Diese Klasse bündelt diese Schritte (es ist das Command aus Beispiel 23,
// ergänzt um die Fehler der Felder). Ein Bildschirm erstellt eines pro Formular:
//
// final _submit = FormSubmit(messages);
// if (await _submit.submit(() => api.register(input))) { ... }
// InputField(..., error: _submit.errors['lastName'])
// =========================================================================
import 'package:flutter/foundation.dart';
import '../api/api_error.dart';
import '../state/messages.dart';
class FormSubmit extends ChangeNotifier {
final Messages _messages;
// der Fehler jedes Felds: ein Übersetzungs-SCHLÜSSEL
Map<String, String> errors = {};
// die Parameter der Fehlermeldungen ({{min}}...), vom Server zurückgesendet
Map<String, String> params = {};
bool submitting = false;
FormSubmit(this._messages);
// führt das Senden aus; gibt true zurück, wenn es erfolgreich war. Bei einem ApiError werden die
// Fehler angezeigt und wir geben false zurück
Future<bool> submit(Future<void> Function() action) async {
if (submitting) return false; // kein doppeltes Senden
errors = {};
params = {};
submitting = true;
notifyListeners();
try {
await action();
return true;
} on ApiError catch (e) {
_messages.showApiError(e);
errors = e.fields;
params = e.params;
return false;
} finally {
submitting = false;
notifyListeners();
}
}
// der Benutzer ändert ein Feld: sein Fehler verschwindet
void clearError(String field) {
if (errors.containsKey(field)) {
errors = {...errors}..remove(field);
notifyListeners();
}
}
}
|
Das Absenden eines Formulars an den Server: das [Command] aus Beispiel 23, ergänzt um Feldfehler (Beispiel 25).
- Zeilen 34–50: Absenden: keine doppelten Übermittlungen; während des Absendens [submitting] (die Schaltflächen sind deaktiviert); bei einem [ApiError]werden die allgemeine Meldung am unteren Bildschirmrand und der Fehler für jedes Feld angezeigt. [finally] wird in jedem Fall ausgeführt, auch nach einem [return];
- Zeilen 55–57: Der Benutzer korrigiert ein Feld; der Fehler verschwindet. Wir ersetzen die [Map] durch eine Kopie, anstatt sie zu ändern: Die alte könnte vom Server geliefert worden sein ([e.fields]), und eine konstante [Map] ([const {}]) lässt sich nicht ändern.
| // =========================================================================
// lib/widgets/input_field.dart - 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'], onChanged: (v) => _edit('lastName', v),
// error: _submit.errors['lastName'])
//
// Es ist ein KONTROLLIERTES Widget (siehe Beispiel 11): Der Wert gehört dem
// übergeordneten Formular; didUpdateWidget kopiert einen Wert, den
// das übergeordnete Widget selbst geändert hat, in das Feld. label, help und error sind Übersetzungs-SCHLÜSSEL;
// params sind die Parameter ihrer Meldungen ({{min}}...).
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../i18n/translations.dart';
class InputField extends StatefulWidget {
final String label;
final String value;
final ValueChanged<String> onChanged;
final String? error;
final String? help;
final Map<String, String> params;
final bool secret; // ein Passwort: verborgene Zeichen
final int? maxLength;
final bool autofocus;
final Iterable<String>? autofill; // für den Passwortmanager des Smartphones
const InputField({
super.key,
required this.label,
required this.value,
required this.onChanged,
this.error,
this.help,
this.params = const {},
this.secret = false,
this.maxLength,
this.autofocus = false,
this.autofill,
});
@override
State<InputField> createState() => _InputFieldState();
}
class _InputFieldState extends State<InputField> {
late final _controller = TextEditingController(text: widget.value);
@override
void didUpdateWidget(InputField old) {
super.didUpdateWidget(old);
if (widget.value != _controller.text) _controller.text = widget.value;
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final error = widget.error;
return Padding(
padding: const EdgeInsets.only(bottom: 8),
child: TextField(
controller: _controller,
obscureText: widget.secret,
autocorrect: !widget.secret,
autofocus: widget.autofocus,
maxLength: widget.maxLength,
autofillHints: widget.autofill,
decoration: InputDecoration(
labelText: t(widget.label),
errorText: error == null ? null : t(error, widget.params),
helperText: widget.help == null ? null : t(widget.help!, widget.params),
helperMaxLines: 2,
errorMaxLines: 3,
counterText: '', // kein Zähler "0/20" unter dem Feld
),
onChanged: widget.onChanged,
),
);
}
}
|
Ein vollständiges Formularfeld: Beschriftung, Feld, Hilfetext oder Fehlermeldung. Alle Formulare verwenden es.
- Zeilen 22–32: die Parameter. Die Beschriftung, der Hilfetext und die Fehlermeldung sind Übersetzungs-SCHLÜSSEL;
- Zeilen 53–58: ein kontrolliertes Widget (Beispiel 11): Der Wert gehört dem übergeordneten Widget. Wenn dieses ihn selbst ändert (das CAPTCHA wird nach einem Fehlschlag geleert), [didUpdateWidget] kopiert ihn zurück in das Feld;
- Zeilen 75–79: Ein Passwort wird maskiert, und die Rechtschreibprüfung greift nicht ein; [autofillHints] teilt dem Passwortmanager des Smartphones mit, was das Feld enthält (einen Benutzernamen, ein Passwort, ein neues Passwort);
- Zeilen 80–86: die Beschriftung, die Fehlermeldung (die den Hilfetext ersetzt) und der Hilfetext. [maxLength] begrenzt die Eingabe und würde unter dem Feld einen Zähler („3/20“) anzeigen; [counterText: ''] blendet ihn aus.
| // =========================================================================
// lib/widgets/person_fields.dart - 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 Widget
// übergibt ihm die Werte, die Fehler und die Funktion, die ein Feld ändert:
// PersonFields(values: _input, errors: _submit.errors, onChanged: _edit)
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../i18n/translations.dart';
import 'input_field.dart';
const titles = ['Mr', 'Mme', 'Melle'];
class PersonFields extends StatelessWidget {
final Map<String, Object?> values;
final Map<String, String> errors;
final void Function(String field, String value) onChanged;
const PersonFields({super.key, required this.values, required this.errors, required this.onChanged});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final titleError = errors['title'];
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
// DropdownButtonFormField: eine Dropdown-Liste mit Label und Fehler
DropdownButtonFormField<String>(
// key: Wird der Wert durch den Code geändert, wird das Feld damit neu erzeugt
key: ValueKey(values['title']),
initialValue: values['title'] as String,
decoration: InputDecoration(
labelText: t('PERSONS.TITLE_LABEL'),
errorText: titleError == null ? null : t(titleError),
),
items: [for (final title in titles) DropdownMenuItem(value: title, child: Text(title))],
onChanged: (title) => onChanged('title', title!),
),
const SizedBox(height: 8),
InputField(
label: 'PERSONS.FIRSTNAME_LABEL',
maxLength: 20,
value: values['firstName'] as String,
onChanged: (v) => onChanged('firstName', v),
error: errors['firstName'],
),
InputField(
label: 'PERSONS.LASTNAME_LABEL',
maxLength: 20,
value: values['lastName'] as String,
onChanged: (v) => onChanged('lastName', v),
error: errors['lastName'],
),
],
);
}
}
|
Die Identitätsfelder (Anrede, Vorname, Nachname), die den ADMIN-Formularen, dem Formular zum Anlegen eines Kontos und dem Formular „Mein Konto verwalten“ gemeinsam sind.
- Zeile 21: Das übergeordnete Widget übergibt die Werte, die Fehler und EINE Funktion zum Ändern eines beliebigen Feldes;
- Zeilen 33–42: Die Anrede in einer Dropdown-Liste, mit Beschriftung und Fehlermeldung, wie ein Eingabefeld. [initialValue] wird nur beim Erstellen des Feldes gelesen; der Schlüssel ([ValueKey]) erstellt es neu, wenn sich der Wert per Code ändert.
| // =========================================================================
// lib/widgets/captcha_field.dart - das Captcha-Bild und das Eingabefeld
// -------------------------------------------------------------------------
// Ein Anzeige-Widget: das Bild (svg), der Button "Another image"
// (onReload) und das Feld, KONTROLLIERT vom übergeordneten Formular (value,
// onChanged). Das Bild und seine Kennung werden von der Login-Seite beim
// Server angefordert, die sie braucht, um die Antwort zu senden.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:flutter_svg/flutter_svg.dart';
import 'package:provider/provider.dart';
import '../i18n/translations.dart';
import 'input_field.dart';
class CaptchaField extends StatelessWidget {
final String? svg;
final String value;
final ValueChanged<String> onChanged;
final VoidCallback onReload;
final String? error;
const CaptchaField({
super.key,
required this.svg,
required this.value,
required this.onChanged,
required this.onReload,
this.error,
});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(t('CAPTCHA.LABEL'), style: Theme.of(context).textTheme.bodySmall),
Row(
children: [
Container(
height: 54,
width: 160,
decoration: BoxDecoration(
color: const Color(0xFFF5F7FA),
border: Border.all(color: Colors.grey.shade300),
borderRadius: BorderRadius.circular(6),
),
// Semantics: was ein Screenreader anstelle des Bildes vorliest
child: svg == null
? null
: Semantics(
label: t('CAPTCHA.IMAGE_ALT'),
child: SvgPicture.string(svg!, fit: BoxFit.contain),
),
),
TextButton.icon(
onPressed: onReload,
icon: const Icon(Icons.refresh),
label: Text(t('CAPTCHA.NEW_IMAGE')),
),
],
),
InputField(
label: 'CAPTCHA.LABEL',
help: 'CAPTCHA.HELP',
maxLength: 10,
value: value,
onChanged: onChanged,
error: error,
),
],
);
}
}
|
Das CAPTCHA-Bild, die Schaltfläche „Anderes Bild“ und das Feld. Das Widget ruft den Server nicht auf: Der Anmeldebildschirm fordert das Bild an, weil er dessen Kennung benötigt, um die Antwort zu senden.
- Zeilen 51–53: das SVG-Bild, als Text empfangen ([SvgPicture.string], Beispiel 22). [Semantics]: das, was ein Screenreader anstelle des Bildes vorliest ([TalkBack] von [Android]).
| // =========================================================================
// lib/widgets/confirmation.dart - "Are you sure?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 16. Die Meldung ist ein Übersetzungs-SCHLÜSSEL:
// if (await confirm(context, 'SCHEDULE.CANCEL_CONFIRM')) { ... }
// "No, go back" statt "Cancel": Die Frage lautet manchmal "Cancel this
// appointment?", und ein Button "Cancel" wäre dort mehrdeutig. Der Fokus liegt auf
// "No": Ein unbedachtes Drücken der Eingabetaste löscht nichts.
// Eine neue Frage löscht die Meldungen der vorherigen Aktion.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../state/messages.dart';
import '../i18n/translations.dart';
Future<bool> confirm(BuildContext context, String key) async {
context.read<Messages>().clear();
final t = context.read<Translations>().t;
final yes = await showDialog<bool>(
context: context,
builder: (context) => AlertDialog(
title: Text(t('CONFIRMATION.TITLE')),
content: Text(t(key)),
actions: [
TextButton(autofocus: true, onPressed: () => Navigator.pop(context, false), child: Text(t('CONFIRMATION.NO'))),
FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red.shade700),
onPressed: () => Navigator.pop(context, true),
child: Text(t('CONFIRMATION.YES')),
),
],
),
);
return yes ?? false;
}
|
Das Bestätigungsfenster aus Beispiel 16, übersetzt: [if (await confirm(context, 'SCHEDULE.CANCEL_CONFIRM')) ...]. Der Fokus liegt auf „Nein“ ([autofocus]): Im Web löscht ein versehentliches Drücken der Eingabetaste nichts.
| // =========================================================================
// lib/widgets/booking_dialog.dart - der Buchungsdialog eines Zeitfensters
// -------------------------------------------------------------------------
// Ein Fenster über dem Terminkalender, einschließlich grauem Hintergrund. Es wird NICHT
// mit showDialog geöffnet: Es ist Teil des Terminkalender-Bildschirms, der
// es anzeigt, wenn seine ADRESSE es verlangt (/schedule?...&book=7, siehe
// pages/schedule.dart). Die Adresse beschreibt somit den ganzen Bildschirm, Dialog inbegriffen.
//
// Das Widget spricht nicht mit dem Server: Es ruft
// - onConfirm mit dem gewählten Patienten auf (null für einen Patienten, der
// für sich selbst bucht);
// - onClose.
// Der Terminkalender-Bildschirm entscheidet, was damit geschieht.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../api/types.dart';
import '../i18n/translations.dart';
class BookingDialog extends StatefulWidget {
final String time; // "8:00 - 8:20"
final List<Person> clients; // ADMIN / DOCTOR: die zur Auswahl stehenden Patienten
final String? patient; // USER: Der Patient ist der Benutzer selbst
final bool submitting;
final ValueChanged<int?> onConfirm;
final VoidCallback onClose;
const BookingDialog({
super.key,
required this.time,
required this.clients,
required this.patient,
required this.submitting,
required this.onConfirm,
required this.onClose,
});
@override
State<BookingDialog> createState() => _BookingDialogState();
}
class _BookingDialogState extends State<BookingDialog> {
int? _clientId;
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final patient = widget.patient;
return Stack(
children: [
// ModalBarrier: der graue Hintergrund; seine Berührung schließt den Dialog
ModalBarrier(color: Colors.black54, onDismiss: widget.onClose),
Center(
child: Card(
margin: const EdgeInsets.all(24),
child: Padding(
padding: const EdgeInsets.all(20),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(t('BOOKING_DIALOG.TITLE'), style: Theme.of(context).textTheme.titleLarge),
const SizedBox(height: 12),
Text(t('BOOKING_DIALOG.SLOT', {'time': widget.time})),
const SizedBox(height: 12),
// ein Patient bucht für sich selbst: keine Liste (und der Server
// würde eine eventuelle clientId ohnehin ignorieren)
if (patient != null)
Text.rich(
TextSpan(
children: [
TextSpan(text: '${t('BOOKING_DIALOG.PATIENT_LABEL')}: '),
TextSpan(
text: patient,
style: const TextStyle(fontWeight: FontWeight.bold),
),
],
),
)
else
DropdownButtonFormField<int?>(
initialValue: _clientId,
isExpanded: true,
decoration: InputDecoration(labelText: t('BOOKING_DIALOG.PATIENT_LABEL')),
items: [
DropdownMenuItem(value: null, child: Text(t('BOOKING_DIALOG.CHOOSE_PATIENT'))),
for (final c in widget.clients) DropdownMenuItem(value: c.id, child: Text(c.label)),
],
onChanged: (id) => setState(() => _clientId = id),
),
const SizedBox(height: 20),
// OverflowBar: die Buttons nebeneinander, untereinander, wenn sie nicht passen
OverflowBar(
alignment: MainAxisAlignment.end,
spacing: 8,
children: [
TextButton(onPressed: widget.onClose, child: Text(t('BOOKING_DIALOG.CANCEL'))),
FilledButton(
onPressed: widget.submitting ? null : () => widget.onConfirm(_clientId),
child: Text(t('BOOKING_DIALOG.CONFIRM')),
),
],
),
],
),
),
),
),
],
);
}
}
|
Das Fenster zur Reservierung eines Zeitfensters. Es wird NICHT durch [showDialog] geöffnet: Es ist Teil des Kalenderbildschirms, der es anzeigt, wenn seine Adresse dies verlangt ([&book=7]).
- Zeilen 23–28: Das Widget kommuniziert nicht mit dem Server; es erhält die Daten, die es anzeigt, sowie zwei Funktionen, die zum Bestätigen (mit dem ausgewählten Patienten) oder zum Schließen aufgerufen werden;
- Zeilen 51–54: Ein [Stack] legt seine Kinder übereinander: zuerst eine [ModalBarrier] – mit ausgegrautem Hintergrund –, die den gesamten Bildschirm bedeckt und Berührungen blockiert, die für den Kalender bestimmt sind (ein Antippen schließt das Fenster), dann das Fenster selbst, zentriert;
- Zeilen 70–91: Ein Patient reserviert für sich selbst: sein Name, ohne Liste. Entweder der ADMIN oder der Arzt wählt den Patienten aus einer Dropdown-Liste aus; die Auswahl bestimmt den Zustand des Fensters;
- Zeilen 95–102: die Schaltflächen ([OverflowBar]: nebeneinander oder untereinander, wenn sie nicht passen); „Bestätigen“ ist während des Absendens deaktiviert.
11.13. Die Bildschirme
11.13.1. lib/pages/login.dart
| // =========================================================================
// lib/pages/login.dart - der Login-Bildschirm (/login)
// -------------------------------------------------------------------------
// 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?login=jbernard: Das Login-Feld ist vorausgefüllt (direkt nach der
// Erstellung eines Kontos).
// Nach einem erfolgreichen Login navigiert dieser Bildschirm NICHT selbst: Die
// Sitzung ändert sich, und der Router verlässt den Login-Bildschirm
// (zu /login?redirect=... oder zur Startseite der Rolle, siehe router.dart).
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/messages.dart';
import '../state/session.dart';
import '../i18n/translations.dart';
import '../widgets/captcha_field.dart';
import '../widgets/input_field.dart';
import '../widgets/form_submit.dart';
import '../widgets/page_title.dart';
class LoginPage extends StatefulWidget {
final String login; // das Login der Adresse (?login=...)
const LoginPage({super.key, this.login = ''});
@override
State<LoginPage> createState() => _LoginPageState();
}
class _LoginPageState extends State<LoginPage> {
late final _api = context.read<RdvMedecinsApi>();
late final _messages = context.read<Messages>();
late final _submit = FormSubmit(_messages);
late final Map<String, String> _input = {'login': widget.login, 'password': '', 'captcha': ''};
Captcha? _captcha;
@override
void initState() {
super.initState();
_reloadCaptcha();
}
@override
void dispose() {
_submit.dispose();
super.dispose();
}
// ein neues Bild: Es wird nach JEDEM Versuch benötigt, denn ein Bild kann nur
// EINMAL verwendet werden (der Server vergisst es, sobald er es geprüft hat)
Future<void> _reloadCaptcha() async {
Captcha? captcha;
try {
captcha = await _api.captcha();
} catch (_) {
captcha = null; // Server nicht erreichbar: Das Login scheitert mit einer klaren Meldung
}
if (mounted) setState(() => _captcha = captcha);
}
void _edit(String field, String value) {
setState(() => _input[field] = value);
_submit.clearError(field);
}
// die beiden Buttons teilen sich diesen Ablauf: Senden und bei einem Fehler
// Fehlermeldung und ein NEUES Bild
Future<void> _attempt(Future<void> Function() action) async {
_messages.clear();
final succeeded = await _submit.submit(action);
if (!succeeded && mounted) {
setState(() => _input['captcha'] = '');
await _reloadCaptcha();
}
}
// bei Erfolg ist hier nichts weiter zu tun: Der Router wechselt den Bildschirm
Future<void> _logIn() => _attempt(
() => context.read<Session>().logIn(
_input['login']!.trim(),
_input['password']!,
_captcha?.id ?? '',
_input['captcha']!,
),
);
Future<void> _createAccount() => _attempt(() async {
await _api.registrationAccess(_captcha?.id ?? '', _input['captcha']!);
if (mounted) context.go('/register');
});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return PageTitle(
titleKey: 'LOGIN.TITLE',
child: ListenableBuilder(
listenable: _submit,
builder: (context, _) => ListView(
padding: const EdgeInsets.all(16),
children: [
Text(t('LOGIN.TITLE'), style: Theme.of(context).textTheme.headlineSmall),
const SizedBox(height: 12),
// AutofillGroup: Der Passwortmanager des Smartphones kann das Formular ausfüllen
AutofillGroup(
child: Column(
children: [
InputField(
label: 'LOGIN.LOGIN_LABEL',
value: _input['login']!,
onChanged: (v) => _edit('login', v),
error: _submit.errors['login'],
autofill: const [AutofillHints.username],
),
InputField(
label: 'LOGIN.PASSWORD_LABEL',
secret: true,
value: _input['password']!,
onChanged: (v) => _edit('password', v),
error: _submit.errors['password'],
autofill: const [AutofillHints.password],
),
],
),
),
CaptchaField(
svg: _captcha?.svg,
value: _input['captcha']!,
onChanged: (v) => _edit('captcha', v),
onReload: _reloadCaptcha,
error: _submit.errors['captcha'],
),
const SizedBox(height: 8),
FilledButton(onPressed: _submit.submitting ? null : _logIn, child: Text(t('LOGIN.SUBMIT'))),
const SizedBox(height: 12),
OutlinedButton(onPressed: _submit.submitting ? null : _createAccount, child: Text(t('LOGIN.CREATE_ACCOUNT'))),
Padding(
padding: const EdgeInsets.only(top: 4),
child: Text(
t('LOGIN.CREATE_ACCOUNT_HELP'),
textAlign: TextAlign.center,
style: Theme.of(context).textTheme.bodySmall,
),
),
const SizedBox(height: 16),
_DemoAccounts(t: t),
],
),
),
);
}
}
// die Demo-Konten
class _DemoAccounts extends StatelessWidget {
final String Function(String, [Map<String, Object?>]) t;
const _DemoAccounts({required this.t});
@override
Widget build(BuildContext context) {
const code = TextStyle(fontFamily: 'RobotoMono', fontSize: 12);
final style = Theme.of(context).textTheme.bodySmall!.copyWith(color: Colors.grey.shade700);
return DefaultTextStyle(
style: style,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(t('LOGIN.DEMO_ACCOUNTS')),
for (final (accounts, roleKey) in [
('admin', 'LOGIN.DEMO_ADMIN'),
('pelissier, tatou, dupont', 'LOGIN.DEMO_DOCTOR'),
('martin, durand, bistrou, german', 'LOGIN.DEMO_USER'),
])
Text.rich(
TextSpan(
children: [
const TextSpan(text: '• '),
TextSpan(text: accounts, style: code),
TextSpan(text: ' - ${t(roleKey)}'),
],
),
),
],
),
);
}
}
|
Der Anmeldebildschirm.
- Zeilen 39–43: Zustand: die API-Zugriffsschicht und die Meldungen (nur EINMAL gelesen, [late]: bei der ersten Verwendung), das Absenden des Formulars, die Dateneingabe (eine [Map]: Feldname -> Wert) und das empfangene CAPTCHA;
- Zeilen 59–66: ein neues Bild beim Öffnen des Bildschirms, auf Anforderung und nach JEDEM Versuch (ein Bild wird nur einmal verwendet);
- Zeilen 76–81: Beide Schaltflächen folgen dieser Abfolge: Absenden und, bei einem Fehlschlag, Leeren des CAPTCHA und Anzeigen eines neuen Bildes;
- Zeilen 86–93: Anmeldung. Bei Erfolg unternimmt der Bildschirm nichts weiter: Die Sitzung ändert sich, und der Router, der darauf lauscht, verlässt den Anmeldebildschirm (siehe [router.dart]);
- Zeilen 95–97: „Patientenkonto anlegen“: Der Server prüft das CAPTCHA und stellt ein Token aus (ein Cookie); anschließend öffnet sich der Bildschirm zum Anlegen des Kontos;
- Zeilen 105–106: Der Bildschirm wird neu geladen, wenn sich der Status des Absendens ändert (in Bearbeitung, Fehler);
- Zeilen 113–129: [AutofillGroup] fasst Benutzernamen und Passwort zusammen: Der Passwortmanager des Smartphones füllt sie gemeinsam aus und bietet nach der Anmeldung an, das Konto zu speichern;
- Zeilen 163–195: Demokonten. [for (final (accounts, roleKey) in [...])]: eine Schleife über eine Liste von Records, die dabei destrukturiert werden (Beispiel 03).
11.13.2. lib/pages/schedule.dart
| // =========================================================================
// lib/pages/schedule.dart - der Terminkalender-Bildschirm (/schedule)
// -------------------------------------------------------------------------
// Drei Blöcke, wie bei den anderen Clients:
// 1. die Auswahl des Arztes und des Tages;
// 2. der Terminkalender dieses Arztes an diesem Tag;
// 3. der Buchungsdialog eines Zeitfensters.
//
// Der GESAMTE Zustand des Bildschirms steckt in seiner ADRESSE:
// /schedule?doctorId=1&day=2026-10-05 der Terminkalender
// /schedule?doctorId=1&day=2026-10-05&book=7 + der Buchungsdialog
// Der Router übergibt diese drei Parameter an das Widget; der Bildschirm LEITET
// daraus ab, was er anzeigt, und die Aktionen des Benutzers ändern die Adresse
// (context.go, context.push). Im Web kann man daher die Seite neu laden,
// ein Lesezeichen setzen, Zurück / Vor verwenden; auf dem Smartphone schließt der
// Zurück-Button 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 die Namen der anderen Patienten.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/api_error.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/cache.dart';
import '../state/messages.dart';
import '../state/session.dart';
import '../formatting.dart';
import '../i18n/translations.dart';
import '../widgets/confirmation.dart';
import '../widgets/booking_dialog.dart';
import '../widgets/page_title.dart';
// die Adresse des Terminkalenders (ohne oder mit Buchungsdialog)
String scheduleAddress(int? doctorId, String day, [int? book]) => Uri(
path: '/schedule',
queryParameters: {'doctorId': '${doctorId ?? ''}', 'day': day, 'book': ?book?.toString()},
).toString();
class SchedulePage extends StatefulWidget {
final int? doctorId;
final String? day; // unverändert aus der Adresse: möglicherweise ungültig
final int? book;
const SchedulePage({super.key, this.doctorId, this.day, this.book});
@override
State<SchedulePage> createState() => _SchedulePageState();
}
class _SchedulePageState extends State<SchedulePage> {
late final _api = context.read<RdvMedecinsApi>();
late final _cache = context.read<Cache>();
late final _messages = context.read<Messages>();
Future<List<Person>>? _doctors;
List<Person> _clients = [];
Future<Schedule>? _schedule;
bool _submitting = false;
// der Tag: der aus der Adresse, wenn er gültig ist, sonst heute
bool get _invalidDay => widget.day != null && !isValidDate(widget.day!);
String get _day => widget.day != null && !_invalidDay ? widget.day! : today();
@override
void initState() {
super.initState();
final user = context.read<Session>().user;
_doctors = _cache.read('doctors', () => _api.list(PersonType.doctors));
// die Patienten: nur für diejenigen, die sie lesen dürfen (Buchungsdialog)
if (user.isManager) {
_cache.read('clients', () => _api.list(PersonType.clients)).then((c) {
if (mounted) setState(() => _clients = c);
}, onError: _messages.showApiError);
}
if (_invalidDay) {
// nachdem der Bildschirm gebaut wurde: Wir ändern keinen anderen Zustand während eines Builds
WidgetsBinding.instance.addPostFrameCallback((_) => _messages.showError('ERRORS.INVALID_DATE'));
}
_loadSchedule();
// ungültig gemachte Daten (Buchung, Stornierung): Wir lesen den Terminkalender neu.
// Vor allem für den Bildschirm nützlich, der UNTER dem Buchungsdialog verborgen ist (siehe _confirmBooking)
_cache.addListener(_loadSchedule);
}
@override
void dispose() {
_cache.removeListener(_loadSchedule);
super.dispose();
}
// der Router verwendet den Bildschirm mit einer anderen Adresse wieder (anderer Arzt, anderer Tag)
@override
void didUpdateWidget(SchedulePage old) {
super.didUpdateWidget(old);
if (old.doctorId != widget.doctorId || old.day != widget.day) _loadSchedule();
}
void _loadSchedule() {
final user = context.read<Session>().user;
// ohne Arzt in der Adresse sieht ein DOCTOR IHREN Terminkalender (der Server
// findet ihn anhand des Tokens); die anderen sehen nichts
final withSchedule = !_invalidDay && (widget.doctorId != null || user?.role == Role.doctor);
setState(() {
_schedule = withSchedule
? _cache.read('schedule/${widget.doctorId}/$_day', () => _api.schedule(widget.doctorId, _day))
: null;
});
// ein fehlgeschlagenes Lesen: seine Meldung unten auf dem Bildschirm
_schedule?.then((_) {}, onError: (Object e) => _messages.showApiError(e));
}
// der Server ist die Referenz: Nach jeder Aktion lesen wir den Terminkalender neu
// (und den Bereich des Patienten, der seinen Termin zeigt). Die Invalidierung
// benachrichtigt alle lebenden Terminkalender-Bildschirme, auch diesen (_loadSchedule)
void _reload() {
_cache.invalidate('my-area');
_cache.invalidate('schedule');
}
void _closeBooking(int? doctorId) {
if (context.canPop()) {
context.pop();
} else {
context.go(scheduleAddress(doctorId, _day));
}
}
Future<void> _confirmBooking(ScheduleSlot slot, int? doctorId, int? clientId) async {
final manager = context.read<Session>().user.isManager;
setState(() => _submitting = true);
try {
await _api.book(_day, slot.id, manager ? clientId : null);
_messages.flash(key: 'SCHEDULE.BOOKED');
} on ApiError catch (e) {
if (e.key == 'ERRORS.CHOOSE_PATIENT') {
// kein Patient gewählt: Der Dialog bleibt geöffnet
_messages.showError(e.key);
return; // (finally wird trotzdem ausgeführt)
}
// in der Zwischenzeit belegtes Zeitfenster, Patient, der bereits einen Termin hat...: Die
// Meldung wird im Terminkalender angezeigt, Dialog geschlossen
_messages.flash(success: false, key: e.key, params: e.params);
} finally {
if (mounted) setState(() => _submitting = false);
}
if (!mounted) return;
_closeBooking(doctorId);
_reload();
}
Future<void> _cancel(ScheduleSlot s) async {
if (s.appointmentId == null || !await confirm(context, 'SCHEDULE.CANCEL_CONFIRM')) return;
try {
await _api.cancelAppointment(s.appointmentId!);
_messages.showSuccess('SCHEDULE.CANCELLED');
} on ApiError catch (e) {
_messages.showApiError(e);
}
if (mounted) _reload();
}
@override
Widget build(BuildContext context) {
final translations = context.watch<Translations>();
final t = translations.t;
final user = context.watch<Session>().user;
return PageTitle(
titleKey: 'SCHEDULE.PAGE_TITLE',
// FutureBuilder: der Terminkalender (null, solange er nicht eingetroffen ist oder wenn es keinen gibt)
child: FutureBuilder<Schedule>(
future: _schedule,
builder: (context, state) {
final s = state.data;
// der angezeigte Arzt: der aus der Adresse oder der aus dem empfangenen Terminkalender (DOCTOR)
final doctorId = widget.doctorId ?? s?.doctor.id;
// das Zeitfenster, dessen Buchungsdialog geöffnet ist (&book=7),
// nur wenn es von diesem Benutzer buchbar ist
final toBook = s?.slots.where((c) => c.id == widget.book && c.bookable).firstOrNull;
// die Meldung des Servers an den Patienten, der bereits einen bevorstehenden Termin hat
// ("cancel it to book another one"), erklärt nichts, wenn DIESER
// Termin im angezeigten Terminkalender steht: Wir sehen ihn unter seinem Namen
// mit seinem Button "Cancel". Sie wird nur in den ANDEREN Terminkalendern angezeigt
final info = s != null && !s.slots.any((c) => c.mine) ? s.info : null;
final Widget content;
if (state.connectionState == ConnectionState.waiting) {
content = const Padding(
padding: EdgeInsets.all(24),
child: Center(child: CircularProgressIndicator()),
);
} else if (s != null) {
content = _Schedule(
schedule: s,
language: translations.language,
onBook: (c) => context.push(scheduleAddress(doctorId, _day, c.id)),
onCancel: _cancel,
);
} else {
content = Padding(padding: const EdgeInsets.all(16), child: Text(t('SCHEDULE.EMPTY_STATE')));
}
return Stack(
children: [
ListView(
padding: const EdgeInsets.all(12),
children: [
// 1. die Auswahl des Arztes und des Tages. Ihr Key ändert sich mit der Adresse:
// Flutter erzeugt sie dann neu, und sie beginnt wieder mit den neuen Werten
FutureBuilder<List<Person>>(
future: _doctors,
builder: (context, doctors) => _DoctorDayPicker(
key: ValueKey('$doctorId|$_day'),
doctors: doctors.data ?? const [],
doctorId: doctorId,
day: _day,
onView: (id, day) => context.go(scheduleAddress(id, day)),
),
),
// Patient, der bereits einen bevorstehenden Termin hat: warum es keinen Button "Book" gibt
if (info != null)
Card(
color: Colors.lightBlue.shade50,
child: ListTile(
title: Text(t(info)),
trailing: TextButton(
onPressed: () => context.go('/my-area'),
child: Text(t('APP.MENU_MY_AREA')),
),
),
),
content,
],
),
// 3. der Buchungsdialog, nur wenn die Adresse &book=... enthält
if (toBook != null)
BookingDialog(
time: timeRange(toBook),
clients: _clients,
patient: user.isPatient ? user!.name : null,
submitting: _submitting,
onConfirm: (clientId) => _confirmBooking(toBook, doctorId, clientId),
onClose: () => _closeBooking(doctorId),
),
],
);
},
),
);
}
}
// -------------------------------------------------------------------------
// 1. die Auswahl des Arztes und des Tages: ein kleines Formular, dessen Zustand
// nur vor dem Senden nützlich ist. Es BEGINNT mit den Werten der Adresse.
// -------------------------------------------------------------------------
class _DoctorDayPicker extends StatefulWidget {
final List<Person> doctors;
final int? doctorId;
final String day;
final void Function(int? doctorId, String day) onView;
const _DoctorDayPicker({
super.key,
required this.doctors,
required this.doctorId,
required this.day,
required this.onView,
});
@override
State<_DoctorDayPicker> createState() => _DoctorDayPickerState();
}
class _DoctorDayPickerState extends State<_DoctorDayPicker> {
late int? _doctorId = widget.doctorId;
late String _day = widget.day;
Future<void> _pickDay() async {
final choice = await showDatePicker(
context: context,
initialDate: DateTime.parse(_day),
firstDate: DateTime(2020),
lastDate: DateTime(2035, 12, 31),
);
if (choice != null) setState(() => _day = toDay(choice));
}
@override
Widget build(BuildContext context) {
final translations = context.watch<Translations>();
final t = translations.t;
// der gewählte Arzt muss in der Liste stehen (sonst: keiner)
final knownId = widget.doctors.any((d) => d.id == _doctorId) ? _doctorId : null;
return Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
DropdownButtonFormField<int?>(
key: ValueKey('${widget.doctors.length}/$knownId'),
initialValue: knownId,
isExpanded: true,
decoration: InputDecoration(labelText: t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')),
items: [
DropdownMenuItem(value: null, child: Text(t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR'))),
for (final d in widget.doctors) DropdownMenuItem(value: d.id, child: Text(d.label)),
],
onChanged: (id) => setState(() => _doctorId = id),
),
const SizedBox(height: 8),
// der Tag: ein Button, der den Kalender öffnet
InputDecorator(
decoration: InputDecoration(labelText: t('DOCTOR_DAY_PICKER.DAY_LABEL')),
child: InkWell(
onTap: _pickDay,
child: Row(
children: [
Expanded(child: Text(longDate(_day, translations.language))),
const Icon(Icons.calendar_month),
],
),
),
),
const SizedBox(height: 12),
FilledButton(
onPressed: knownId == null ? null : () => widget.onView(knownId, _day),
child: Text(t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE')),
),
],
),
),
);
}
}
// -------------------------------------------------------------------------
// 2. der Terminkalender
// -------------------------------------------------------------------------
class _Schedule extends StatelessWidget {
final Schedule schedule;
final String language;
final ValueChanged<ScheduleSlot> onBook;
final ValueChanged<ScheduleSlot> onCancel;
const _Schedule({required this.schedule, required this.language, required this.onBook, required this.onCancel});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final s = schedule;
return Card(
child: Padding(
padding: const EdgeInsets.symmetric(vertical: 8),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
ListTile(
title: Text(
'${t('SCHEDULE.TITLE_PREFIX')} ${longDate(s.day, language)}',
style: Theme.of(context).textTheme.titleMedium,
),
subtitle: Text(s.doctor.label),
),
if (s.slots.isEmpty) Padding(padding: const EdgeInsets.all(16), child: Text(t('SCHEDULE.NO_SLOTS'))),
for (final c in s.slots) ...[
const Divider(height: 1),
ListTile(
// die buchbaren Zeitfenster sind leicht eingefärbt
tileColor: c.bookable ? Colors.green.shade50 : null,
leading: SizedBox(
width: 96,
child: Text(timeRange(c), style: const TextStyle(fontWeight: FontWeight.w500)),
),
title: Align(
alignment: Alignment.centerLeft,
child: c.free
? _Badge(t('SCHEDULE.FREE'), Colors.green.shade700)
: c.patient != null
? _Badge(c.patient!.label, c.mine ? Colors.indigo : Colors.grey.shade600)
: _Badge(t('SCHEDULE.BOOKED_BY_OTHER'), Colors.grey.shade600),
),
// "Book" ändert die ADRESSE (&book=...), wodurch der Buchungsdialog geöffnet wird
trailing: c.bookable
? OutlinedButton(onPressed: () => onBook(c), child: Text(t('SCHEDULE.BOOK')))
: c.appointmentId != null
? OutlinedButton(
style: OutlinedButton.styleFrom(foregroundColor: Colors.red.shade700),
onPressed: () => onCancel(c),
child: Text(t('SCHEDULE.CANCEL_APPOINTMENT')),
)
: null,
),
],
],
),
),
);
}
}
// ein farbiges Label (das "Badge" der anderen Clients)
class _Badge extends StatelessWidget {
final String text;
final Color color;
const _Badge(this.text, this.color);
@override
Widget build(BuildContext context) {
return Container(
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 3),
decoration: BoxDecoration(color: color, borderRadius: BorderRadius.circular(6)),
child: Text(
text,
style: const TextStyle(color: Colors.white, fontSize: 12, fontWeight: FontWeight.bold),
),
);
}
}
|
Der funktionsreichste Bildschirm: Auswahl eines Arztes und eines Tages, der Kalender und das Reservierungsfenster.
- Zeilen 40–43: die Adresse des Kalenders. Der GESAMTE Zustand des Bildschirms ist in seiner Adresse enthalten; Benutzeraktionen ändern sie, und der Bildschirm bestimmt anhand dessen, was angezeigt wird;
- Zeilen 66–67: der Tag aus der Adresse, sofern gültig; andernfalls heute;
- Zeilen 70–87: Beim Öffnen des Bildschirms: die Ärzte (aus dem Cache – sie werden einmal für die gesamte Sitzung geladen), die Patienten, wenn der Benutzer berechtigt ist, sie einzusehen (für das Reservierungsfenster), und der Kalender. Wenn das Datum in der Adresse ungültig ist, wird eine Meldung angezeigt, NACHDEM der Bildschirm aufgebaut wurde ([addPostFrameCallback]: Ein anderer Zustand wird während des Aufbaus des Bildschirms nicht geändert). Schließlich liest der Bildschirm aus dem Cache;
- Zeilen 98–100: „Terminkalender anzeigen“ ändert die Adresse; der Router VERWENDET den Bildschirm WIEDER (gleiche Route) mit neuen Parametern: [didUpdateWidget] liest dann den Kalender erneut;
- Zeilen 103–114: Der Cache liest den Terminkalender. Ist in der Adresse kein Arzt angegeben, sieht ein angemeldeter Arzt SEINEN Terminkalender (der Server ermittelt ihn anhand des Tokens);
- Zeilen 120–122: Nach einer Reservierung oder Stornierung haben die Daten des Servers Vorrang: Der Kalender (und der Patientenbereich) wird ungültig gemacht; der Cache benachrichtigt die Kalenderbildschirme, die sich neu laden;
- Zeilen 125–129: Das Fenster schließen: zurück zur vorherigen URL. „Reservieren“ hat die URL mit [&book=] auf den Stack GELEGT ([context.push]): Sie wird zurückgenommen ([context.pop]), genau wie es die Zurück-Taste des Smartphones tut. Wurde der Bildschirm direkt unter dieser Adresse geöffnet (im Web), gibt es nichts zurückzunehmen: Es geht zur Adresse des Kalenders;
- Zeilen 133–153: die Terminreservierung. Ist kein Patient ausgewählt, bleibt das Fenster geöffnet und zeigt die Meldung an. Jede andere Aktion schließt das Fenster, und die Meldung (Erfolg oder Fehler – etwa ein zwischenzeitlich vergebenes Zeitfenster ...) erscheint als Pop-up-Meldung für den Kalender. Der Kalenderbildschirm, der das Fenster enthält, verschwindet; der darunterliegende erscheint wieder, dank des Caches;
- Zeilen 156–164: die Stornierung, nach Bestätigung;
- Zeilen 176–184: Der Bildschirm zeigt den Kalender an ([FutureBuilder]). Das Zeitfenster im Reservierungsfenster ist das aus der Adresse ([&book=7]), aber nur, wenn es VON DIESEM BENUTZER reservierbar ist (ein zwischenzeitlich vergebenes Zeitfenster, eine manuell erstellte Adresse: kein Fenster);
- Zeile 189: Der Server sendet diese Meldung ([info]) zusammen mit ALLEN Kalendern; doch im Kalender, der den Termin des Patienten enthält (ein Zeitfenster [mine]), ist sie überflüssig – und unmittelbar nach einer Reservierung sogar irreführend: Der Patient sieht seinen Termin, unter seinem Namen aufgeführt, mit einer Schaltfläche „Stornieren“. Daher wird sie nur in den anderen Kalendern angezeigt. [s.slots.any((c) => c.mine)]: wahr, wenn mindestens ein Zeitfenster die Bedingung erfüllt;
- Zeilen 201–202: „Reservieren“ legt die Adresse des Fensters auf den Stack;
- Zeilen 215–222: Auswahl des Arztes und des Tages. Ihr Schlüssel enthält den Arzt und den Tag aus der URL: Wenn sich die URL ändert (Zurück-Taste des Smartphones, Zurück-Schaltfläche des Browsers), [Flutter] erstellt das Widget neu, das mit den neuen Werten von vorn beginnt;
- Zeilen 226–233: ein Patient, der bereits einen bevorstehenden Termin hat: der Grund, warum es keine Schaltfläche „Reservieren“ gibt (siehe [info], oben);
- Zeilen 241–248: das Reservierungsfenster, über dem Kalender (in einem [Stack]);
- Zeilen 280–291: Auswahl des Arztes und des Tages: ein kurzes Formular, dessen Zustand mit den Werten der Adresse BEGINNT. [late int? _doctorId = widget.doctorId;]: ein Feld, das aus [widget] initialisiert wird, ermöglicht durch [late]. [showDatePicker] öffnet den Kalender von [Material] in der Sprache der Anwendung;
- Zeilen 319–326: Der Tag wird als Eingabefeld angezeigt ([InputDecorator]: die Beschriftung und der Rahmen eines Feldes, die ein beliebiges Widget umgeben), das Sie antippen, um den Kalender zu öffnen;
- Zeilen 346–406: der Terminkalender. Eine Zeile pro Zeitfenster: die Uhrzeit, eine Beschriftung (benutzerdefinierter Text, der Name des Patienten oder „Belegt“ für einen anderen Patienten) und die vom SERVER aktivierte Schaltfläche ([bookable], [appointmentId]).
11.13.3. lib/pages/persons_config.dart
| // =========================================================================
// lib/pages/persons_config.dart - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Verwaltungsbildschirme der Ärzte und der Clients sind IDENTISCH: gleiche
// Liste, gleiches Formular. Wir schreiben sie EINMAL (persons.dart,
// person_form.dart); nur die Adresse der API und die
// Schlüssel der Labels ändern sich, hier beschrieben. Der Router übergibt jedem Bildschirm den Typ.
// =========================================================================
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
typedef PersonKeys = ({
String title, // "Doctors"
String add, // "Add a doctor"
String edit, // "Edit a doctor"
String empty, // "No doctors."
String confirmDelete,
String added, // "Doctor {{name}} has been added (login: {{login}})."
String edited,
String deleted,
String notFound, // der Datensatz wurde in der Zwischenzeit gelöscht
});
PersonKeys keys(PersonType type) => switch (type) {
PersonType.doctors => (
title: 'DOCTORS.TITLE',
add: 'DOCTORS.ADD',
edit: 'DOCTORS.EDIT',
empty: 'DOCTORS.EMPTY',
confirmDelete: 'DOCTORS.DELETE_CONFIRM',
added: 'DOCTORS.ADDED',
edited: 'DOCTORS.UPDATED',
deleted: 'DOCTORS.DELETED',
notFound: 'ERRORS.DOCTOR_NOT_FOUND',
),
PersonType.clients => (
title: 'CLIENTS.TITLE',
add: 'CLIENTS.ADD',
edit: 'CLIENTS.EDIT',
empty: 'CLIENTS.EMPTY',
confirmDelete: 'CLIENTS.DELETE_CONFIRM',
added: 'CLIENTS.ADDED',
edited: 'CLIENTS.UPDATED',
deleted: 'CLIENTS.DELETED',
notFound: 'ERRORS.PATIENT_NOT_FOUND',
),
};
// {{name}} und {{login}} der Meldungen "added / updated / deleted"
Map<String, String> messageParams(Person p) => {'name': '${p.firstName} ${p.lastName}', 'login': p.login ?? ''};
|
Die Bildschirme für Ärzte und Klienten sind identisch; nur die hier beschriebenen Beschriftungsschlüssel unterscheiden sich.
- Zeilen 13–22: ein Record mit benannten Feldern, der die Schlüssel für einen Personentyp enthält;
- Zeilen 25–37: ein Ausdruck auf einer Aufzählung: [Dart] stellt sicher, dass alle Fälle behandelt werden. Das Hinzufügen eines Wertes zu [PersonType] würde hier einen Kompilierfehler verursachen;
- Zeile 51: die Parameter für die Meldungen „hinzugefügt“, „geändert“ und „gelöscht“.
11.13.4. lib/pages/persons.dart
| // =========================================================================
// lib/pages/persons.dart - die Liste der Ärzte ODER der Clients (ADMIN)
// -------------------------------------------------------------------------
// Ein Bildschirm für beide: Der Typ (Ärzte oder Clients) kommt als
// Parameter an (siehe router.dart); die jeweils spezifischen Labels stehen in
// persons_config.dart.
// 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.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/api_error.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/cache.dart';
import '../state/messages.dart';
import '../i18n/translations.dart';
import '../widgets/confirmation.dart';
import '../widgets/page_title.dart';
import 'persons_config.dart';
class PersonsPage extends StatefulWidget {
final PersonType type;
const PersonsPage({super.key, required this.type});
@override
State<PersonsPage> createState() => _PersonsPageState();
}
class _PersonsPageState extends State<PersonsPage> {
late final _api = context.read<RdvMedecinsApi>();
late final _cache = context.read<Cache>();
late final _messages = context.read<Messages>();
Future<List<Person>>? _list;
@override
void initState() {
super.initState();
_load();
}
// der Router verwendet den Bildschirm für den anderen Typ wieder (/doctors -> /clients)
@override
void didUpdateWidget(PersonsPage old) {
super.didUpdateWidget(old);
if (old.type != widget.type) _load();
}
void _load() {
final type = widget.type;
setState(() {
_list = _cache.read(type.name, () => _api.list(type));
});
_list!.then((_) {}, onError: (Object e) => _messages.showApiError(e));
}
Future<void> _delete(Person p) async {
final k = keys(widget.type);
if (!await confirm(context, k.confirmDelete)) return;
try {
await _api.remove(widget.type, p.id);
_messages.showSuccess(k.deleted, messageParams(p));
} on ApiError catch (e) {
// ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
_messages.showApiError(e);
}
_cache.invalidate(widget.type.name);
if (mounted) _load();
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final k = keys(widget.type);
final type = widget.type.name;
return PageTitle(
titleKey: k.title,
// ein Scaffold IM Layout: für seinen schwebenden Button
child: Scaffold(
floatingActionButton: FloatingActionButton.extended(
onPressed: () => context.go('/$type/add'),
icon: const Icon(Icons.add),
label: Text(t(k.add)),
),
body: FutureBuilder<List<Person>>(
future: _list,
builder: (context, state) {
final list = state.data;
if (list == null) {
// noch nicht geladen (oder Laden fehlgeschlagen: Die Meldung steht unten auf dem Bildschirm)
return state.hasError ? const SizedBox.shrink() : const Center(child: CircularProgressIndicator());
}
return ListView(
// Platz unten, um die letzte Zeile nicht unter dem schwebenden Button zu verbergen
padding: const EdgeInsets.fromLTRB(8, 8, 8, 88),
children: [
Padding(
padding: const EdgeInsets.all(8),
child: Text(t(k.title), style: Theme.of(context).textTheme.headlineSmall),
),
if (list.isEmpty) ListTile(title: Text(t(k.empty))),
for (final p in list)
Card(
child: ListTile(
leading: CircleAvatar(child: Text('${p.firstName[0]}${p.lastName[0]}')),
title: Text(p.label),
subtitle: Text(p.login ?? '', style: const TextStyle(fontFamily: 'RobotoMono')),
trailing: Row(
mainAxisSize: MainAxisSize.min,
children: [
IconButton(
tooltip: t('PERSONS.EDIT'),
icon: const Icon(Icons.edit),
onPressed: () => context.go('/$type/${p.id}/edit'),
),
IconButton(
tooltip: t('PERSONS.DELETE'),
icon: Icon(Icons.delete_outline, color: Colors.red.shade700),
onPressed: () => _delete(p),
),
],
),
),
),
],
);
},
),
),
);
}
}
|
Die Liste der Ärzte oder Klienten.
- Zeilen 54–59: die Liste, aus dem Cache. Achten Sie auf die geschweiften Klammern in [setState(() { ... })]: Mit einem Pfeil geschrieben, [setState(() => _list = ...)], würde die Funktion den zugewiesenen Wert ZURÜCKGEBEN, in diesem Fall ein [Future], und [setState] lehnt eine Funktion ab, die ein [Future] zurückgibt (die Zustandsaktualisierung muss synchron erfolgen): [Flutter] meldet dies mit einem Fehler;
- Zeilen 62–73: Löschen, nach Bestätigung. Ein Arzt mit Terminen wird vom Server abgelehnt (409 [DOCTOR_HAS_APPOINTMENTS]);
- Zeilen 84–88: ein [Scaffold] innerhalb des [Scaffold] des Layouts, für die schwebende Schaltfläche „+ Hinzufügen“ ([FloatingActionButton]) unten rechts;
- Zeilen 107–124: ein Listeneintrag pro Person ([ListTile]): ein Avatar mit den Initialen, Name, Benutzername und zwei Schaltflächen. Eine Tabelle mit fünf Spalten, wie die für Web-Clients, würde auf einem Smartphone nicht passen.
11.13.5. lib/pages/person_form.dart
| // =========================================================================
// lib/pages/person_form.dart - Anlegen ODER Aktualisieren eines
// Arztes oder eines Clients (ADMIN)
// -------------------------------------------------------------------------
// /doctors/add -> Anlegen (keine id)
// /doctors/3/edit -> Aktualisieren (id = 3)
// (und dieselben Adressen unter /clients).
//
// Zwei Widgets:
// - PersonFormPage liest den zu aktualisierenden Datensatz (falls vorhanden);
// - _Form wird erst angezeigt, wenn der Datensatz gelesen wurde: Es BEGINNT mit
// seinen Werten (Anfangszustand), ohne sie später kopieren zu müssen.
// Keine Regel wird hier geprüft: Der Server validiert alles, und seine Fehler
// werden unter den Feldern angezeigt (siehe widgets/form_submit.dart).
// Die mit dem Datensatz gelesene VERSION geht bei der Aktualisierung zurück: Hat ein anderer
// ADMIN ihn in der Zwischenzeit geändert, antwortet der Server mit 409 CONCURRENT_UPDATE.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/api_error.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/cache.dart';
import '../state/messages.dart';
import '../i18n/translations.dart';
import '../widgets/input_field.dart';
import '../widgets/person_fields.dart';
import '../widgets/form_submit.dart';
import '../widgets/page_title.dart';
import 'persons_config.dart';
const _empty = <String, Object?>{'title': 'Mr', 'firstName': '', 'lastName': '', 'login': '', 'password': ''};
class PersonFormPage extends StatefulWidget {
final PersonType type;
final int? id; // null: Anlegen
const PersonFormPage({super.key, required this.type, this.id});
@override
State<PersonFormPage> createState() => _PersonFormPageState();
}
class _PersonFormPageState extends State<PersonFormPage> {
Future<Person>? _details;
@override
void initState() {
super.initState();
final id = widget.id;
if (id != null) {
// Aktualisierung: Wir lesen den Datensatz (einschließlich seiner Version) OHNE Cache: Er
// muss aktuell sein (sonst würde das Formular mit einer veralteten
// Version beginnen: 409 CONCURRENT_UPDATE)
_details = context.read<RdvMedecinsApi>().read(widget.type, id);
// Datensatz, der nicht existiert (in der Zwischenzeit gelöscht...): zurück zur Liste
_details!.then(
(_) {},
onError: (Object e) {
if (e is! ApiError || !mounted) return;
context.read<Messages>().flash(success: false, key: e.key, params: e.params);
context.go('/${widget.type.name}');
},
);
}
}
@override
Widget build(BuildContext context) {
final k = keys(widget.type);
return PageTitle(
titleKey: widget.id == null ? k.add : k.edit,
child: widget.id == null
? _Form(type: widget.type, id: null, initial: _empty)
: FutureBuilder<Person>(
future: _details,
builder: (context, state) {
final p = state.data;
if (p == null) return const Center(child: CircularProgressIndicator());
return _Form(
type: widget.type,
id: p.id,
initial: {
'title': p.title,
'firstName': p.firstName,
'lastName': p.lastName,
'login': p.login ?? '',
'password': '',
'version': p.version,
},
);
},
),
);
}
}
// das Formular selbst
class _Form extends StatefulWidget {
final PersonType type;
final int? id;
final Map<String, Object?> initial;
const _Form({required this.type, required this.id, required this.initial});
@override
State<_Form> createState() => _FormState();
}
class _FormState extends State<_Form> {
late final _messages = context.read<Messages>();
late final _submit = FormSubmit(_messages);
// eine veränderbare KOPIE der Anfangswerte
late final Map<String, Object?> _input = {...widget.initial};
bool get _creating => widget.id == null;
@override
void dispose() {
_submit.dispose();
super.dispose();
}
void _edit(String field, String value) {
setState(() => _input[field] = value);
_submit.clearError(field);
}
Future<void> _save() async {
final api = context.read<RdvMedecinsApi>();
final cache = context.read<Cache>();
final k = keys(widget.type);
final succeeded = await _submit.submit(() async {
final id = widget.id;
final p = id == null ? await api.add(widget.type, _input) : await api.edit(widget.type, id, _input);
_messages.flash(key: _creating ? k.added : k.edited, params: messageParams(p));
});
if (!mounted) return;
final errorKey = _messages.error?.key;
if (succeeded) {
cache.invalidate(widget.type.name); // die Liste hat sich geändert
context.go('/${widget.type.name}');
} else if (errorKey == k.notFound) {
// in der Zwischenzeit von einem anderen ADMIN gelöscht: zurück zur Liste
_messages.flash(success: false, key: errorKey!);
context.go('/${widget.type.name}');
}
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
final k = keys(widget.type);
return ListenableBuilder(
listenable: _submit,
builder: (context, _) => ListView(
padding: const EdgeInsets.all(16),
children: [
Text(t(_creating ? k.add : k.edit), style: Theme.of(context).textTheme.headlineSmall),
const SizedBox(height: 8),
PersonFields(values: _input, errors: _submit.errors, onChanged: _edit),
const SizedBox(height: 16),
Text(t('PERSONS.ACCOUNT_SECTION'), style: Theme.of(context).textTheme.titleSmall),
InputField(
label: 'PERSONS.LOGIN_LABEL',
maxLength: 30,
value: _input['login'] as String,
onChanged: (v) => _edit('login', v),
error: _submit.errors['login'],
help: _creating ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT',
),
// niemals vorausgefüllt: Das Passwort kommt nie vom Server zurück
InputField(
label: 'PERSONS.PASSWORD_LABEL',
secret: true,
maxLength: 72,
value: _input['password'] as String,
onChanged: (v) => _edit('password', v),
error: _submit.errors['password'],
params: _submit.params,
help: _creating ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT',
),
const SizedBox(height: 16),
Wrap(
spacing: 8,
children: [
FilledButton(onPressed: _submit.submitting ? null : _save, child: Text(t('PERSONS.SAVE'))),
OutlinedButton(onPressed: () => context.go('/${widget.type.name}'), child: Text(t('PERSONS.BACK'))),
],
),
],
),
);
}
}
|
Das Hinzufügen oder Ändern eines Arztes oder eines Klienten.
- Zeilen 54–65: Für eine Änderung wird der Datensatz gelesen; OHNE Cache: Seine Version muss aktuell sein. Wird ein Datensatz nicht gefunden (zwischenzeitlich gelöscht): zurück zur Liste mit einer Meldung;
- Zeilen 78–92: Das Formular wird erst angezeigt, nachdem der Datensatz gelesen wurde, und BEGINNT mit dessen Werten; der Benutzer muss sie später nie erneut eingeben;
- Zeile 117: eine änderbare KOPIE der Anfangswerte ([...]: der Zerlegungsoperator, innerhalb einer [Map]);
- Zeilen 132–149: der Datensatz: [POST] oder [PUT], je nachdem, ob eine Kennung vorhanden ist. Die Erfolgsmeldung ist eine Flash-Meldung: Sie erscheint in der Liste. Wurde ein Datensatz zwischenzeitlich von einem anderen ADMIN gelöscht: zurück zur Liste;
- Zeilen 167–184: der Benutzername und das Passwort, mit unterschiedlichen Hilfetexten für das Anlegen und das Ändern (wird das Passwortfeld leer gelassen, ändert sich das Passwort nicht). Das Passwort wird nie vorausgefüllt: Der Server gibt es nie zurück.
11.13.6. lib/pages/register.dart
| // =========================================================================
// lib/pages/register.dart - "Create a patient account" (/register)
// -------------------------------------------------------------------------
// Wir gelangen nur hierher, nachdem das Captcha des Login-Bildschirms eingegeben wurde
// (Button "Create a patient account"): Der Server hat dann eine
// Berechtigung (ein Cookie) ausgestellt, die der Guard der Route geprüft hat (siehe
// router.dart). Dieselben Felder wie im Formular des ADMIN, aber Login
// und Passwort sind Pflicht, mit Bestätigung.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/rdvmedecins_api.dart';
import '../state/messages.dart';
import '../i18n/translations.dart';
import '../widgets/input_field.dart';
import '../widgets/person_fields.dart';
import '../widgets/form_submit.dart';
import '../widgets/page_title.dart';
// Mindestlänge eines von einem Patienten gewählten Passworts: derselbe Wert
// wie auf dem Server (der bei dem Fehler PASSWORD_TOO_SHORT auch {min} zurücksendet)
const passwordMin = '6';
class RegisterPage extends StatefulWidget {
const RegisterPage({super.key});
@override
State<RegisterPage> createState() => _RegisterPageState();
}
class _RegisterPageState extends State<RegisterPage> {
late final _messages = context.read<Messages>();
late final _submit = FormSubmit(_messages);
final Map<String, Object?> _input = {
'title': 'Mr',
'firstName': '',
'lastName': '',
'login': '',
'password': '',
'confirmation': '',
};
@override
void dispose() {
_submit.dispose();
super.dispose();
}
void _edit(String field, String value) {
setState(() => _input[field] = value);
_submit.clearError(field);
}
Future<void> _create() async {
final api = context.read<RdvMedecinsApi>();
var login = '';
final succeeded = await _submit.submit(() async => login = await api.register(_input));
if (!mounted) return;
if (succeeded) {
// zurück zum Login-Bildschirm, Login vorausgefüllt
_messages.flash(key: 'REGISTRATION.DONE', params: {'login': login});
context.go(Uri(path: '/login', queryParameters: {'login': login}).toString());
} else if (_messages.error?.key == 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
// Berechtigung abgelaufen (15 Minuten): zurück zum Captcha
_messages.flash(success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
context.go('/login');
}
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
// die Parameter der Hilfemeldung UND der Passwortfehler
final passwordParams = {'min': passwordMin, ..._submit.params};
return PageTitle(
titleKey: 'REGISTRATION.TITLE',
child: ListenableBuilder(
listenable: _submit,
builder: (context, _) => ListView(
padding: const EdgeInsets.all(16),
children: [
Text(t('REGISTRATION.TITLE'), style: Theme.of(context).textTheme.headlineSmall),
Text(t('REGISTRATION.INTRO'), style: const TextStyle(color: Colors.grey)),
const SizedBox(height: 8),
PersonFields(values: _input, errors: _submit.errors, onChanged: _edit),
const SizedBox(height: 16),
Text(t('PERSONS.ACCOUNT_SECTION'), style: Theme.of(context).textTheme.titleSmall),
InputField(
label: 'PERSONS.LOGIN_LABEL',
maxLength: 30,
value: _input['login'] as String,
onChanged: (v) => _edit('login', v),
error: _submit.errors['login'],
help: 'REGISTRATION.LOGIN_HELP',
autofill: const [AutofillHints.newUsername],
),
InputField(
label: 'PERSONS.PASSWORD_LABEL',
secret: true,
maxLength: 72,
value: _input['password'] as String,
onChanged: (v) => _edit('password', v),
error: _submit.errors['password'],
params: passwordParams,
help: 'REGISTRATION.PASSWORD_HELP',
autofill: const [AutofillHints.newPassword],
),
InputField(
label: 'ACCOUNT.CONFIRMATION_LABEL',
secret: true,
maxLength: 72,
value: _input['confirmation'] as String,
onChanged: (v) => _edit('confirmation', v),
error: _submit.errors['confirmation'],
),
const SizedBox(height: 16),
Wrap(
spacing: 8,
children: [
FilledButton(onPressed: _submit.submitting ? null : _create, child: Text(t('REGISTRATION.SUBMIT'))),
OutlinedButton(onPressed: () => context.go('/login'), child: Text(t('REGISTRATION.BACK_TO_LOGIN'))),
],
),
],
),
),
);
}
}
|
Das Anlegen eines Patientenkontos, erreichbar mit dem vom Anmeldebildschirm ausgestellten Passierschein (siehe den Guard der Route in [router.dart]).
- Zeile 25: die Mindestlänge des Passworts; für den Hilfetext: derselbe Wert wie beim Server (der ihn auch mit dem Fehler [PASSWORD_TOO_SHORT] zurückgibt);
- Zeilen 57–69: Anlegen. Bei Erfolg: zurück zum Anmeldebildschirm, mit vorausgefülltem Benutzernamen ([/login?login=...]), zusammen mit einer Pop-up-Meldung. Schlägt es fehl, weil der Passierschein abgelaufen ist (15 Minuten): zurück zum CAPTCHA. Jeder andere Fehler bleibt unter den Feldern angezeigt;
- Zeile 77: die Parameter für den Hilfetext und den Passwortfehler ([{{min}}]);
- Zeilen 98–109: ein NEUES Konto: Der Passwortmanager kann ein sicheres Passwort vorschlagen und speichern.
11.13.7. lib/pages/patient_area.dart
| // =========================================================================
// lib/pages/patient_area.dart - "My area" (/my-area, Rolle USER)
// -------------------------------------------------------------------------
// Der Startbildschirm des Patienten, direkt nach dem Login:
// - zwei Optionen: [Manage my account] und [View a schedule];
// - sein bevorstehender Termin, falls er einen hat, mit der Möglichkeit, ihn zu stornieren.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/api_error.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/cache.dart';
import '../state/messages.dart';
import '../formatting.dart';
import '../i18n/translations.dart';
import '../widgets/confirmation.dart';
import '../widgets/page_title.dart';
import 'schedule.dart';
class PatientAreaPage extends StatefulWidget {
const PatientAreaPage({super.key});
@override
State<PatientAreaPage> createState() => _PatientAreaPageState();
}
class _PatientAreaPageState extends State<PatientAreaPage> {
late final _api = context.read<RdvMedecinsApi>();
late final _cache = context.read<Cache>();
late final _messages = context.read<Messages>();
Future<MyArea>? _area;
@override
void initState() {
super.initState();
_load();
}
void _load() {
// geschweifte Klammern: Eine Pfeilfunktion WÜRDE das zugewiesene Future zurückgeben, und
// setState lehnt eine Funktion ab, die ein Future zurückgibt
setState(() {
_area = _cache.read('my-area', _api.myArea);
});
_area!.then((_) {}, onError: (Object e) => _messages.showApiError(e));
}
Future<void> _cancel(int appointmentId) async {
if (!await confirm(context, 'SCHEDULE.CANCEL_CONFIRM')) return;
try {
await _api.cancelAppointment(appointmentId);
_messages.showSuccess('SCHEDULE.CANCELLED');
} on ApiError catch (e) {
_messages.showApiError(e);
}
// der Bereich UND die Terminkalender haben sich geändert
_cache.invalidate('my-area');
_cache.invalidate('schedule');
if (mounted) _load();
}
@override
Widget build(BuildContext context) {
final translations = context.watch<Translations>();
final t = translations.t;
return PageTitle(
titleKey: 'AREA.TITLE',
child: FutureBuilder<MyArea>(
future: _area,
builder: (context, state) {
final a = state.data;
if (a == null) return const Center(child: CircularProgressIndicator());
return ListView(
padding: const EdgeInsets.all(12),
children: [
Padding(
padding: const EdgeInsets.all(4),
child: Text(
t('AREA.HELLO', {'name': a.patient.label}),
style: Theme.of(context).textTheme.headlineSmall,
),
),
_Option(
icon: Icons.manage_accounts,
title: t('AREA.MANAGE_ACCOUNT'),
help: t('AREA.MANAGE_ACCOUNT_HELP'),
onTap: () => context.go('/my-account'),
),
_Option(
icon: Icons.calendar_month,
title: t('AREA.VIEW_SCHEDULE'),
help: t('AREA.VIEW_SCHEDULE_HELP'),
onTap: () => context.go('/schedule'),
),
const SizedBox(height: 8),
Card(
child: Padding(
padding: const EdgeInsets.all(12),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(t('AREA.MY_APPOINTMENT'), style: Theme.of(context).textTheme.titleMedium),
// normalerweise nur einer (Regel "ein bevorstehender Termin
// gleichzeitig"), der Bildschirm kann aber mehrere anzeigen
for (final ap in a.appointments) ...[
const SizedBox(height: 8),
Text(
'${longDate(ap.day, translations.language)}, ${timeRange(ap.slot)}',
style: const TextStyle(fontWeight: FontWeight.w600),
),
Text(ap.doctor.label),
Wrap(
spacing: 8,
children: [
// der Terminkalender des Arztes an diesem Tag: Der Patient sieht darin seinen Namen
TextButton(
onPressed: () => context.go(scheduleAddress(ap.doctor.id, ap.day)),
child: Text(t('AREA.SEE_IN_SCHEDULE')),
),
OutlinedButton(
style: OutlinedButton.styleFrom(foregroundColor: Colors.red.shade700),
onPressed: () => _cancel(ap.id),
child: Text(t('AREA.CANCEL_APPOINTMENT')),
),
],
),
],
if (a.appointments.isEmpty)
Padding(
padding: const EdgeInsets.only(top: 8),
child: Text(t('AREA.NO_APPOINTMENT'), style: const TextStyle(color: Colors.grey)),
),
],
),
),
),
],
);
},
),
);
}
}
// eine Options-"Karte", auf die man tippt, um einen Bildschirm zu öffnen
class _Option extends StatelessWidget {
final IconData icon;
final String title;
final String help;
final VoidCallback onTap;
const _Option({required this.icon, required this.title, required this.help, required this.onTap});
@override
Widget build(BuildContext context) {
return Card(
child: ListTile(
leading: Icon(icon, size: 32, color: Theme.of(context).colorScheme.primary),
title: Text(title, style: Theme.of(context).textTheme.titleMedium),
subtitle: Text(help),
trailing: const Icon(Icons.chevron_right),
onTap: onTap,
),
);
}
}
|
Der Startbildschirm des Patienten: zwei Optionen und sein bevorstehender Termin.
- Zeilen 52–63: Stornierung des Termins: Der Bereich UND die Terminkalender haben sich geändert;
- Zeilen 109–127: der Termin und zwei Schaltflächen: den Terminkalender des Arztes für diesen Tag anzeigen (der Patient sieht dort seinen Namen), stornieren;
- Zeilen 150–166: eine Option: eine Karte, die Sie antippen, um einen Bildschirm zu öffnen.
11.13.8. lib/pages/my_account.dart
| // =========================================================================
// lib/pages/my_account.dart - "Manage my account" (/my-account, Rolle USER)
// -------------------------------------------------------------------------
// Zwei unabhängige Formulare:
// 1. die Aktualisierung (Identität, Login, optionales neues Passwort);
// 2. die Löschung des Kontos - die auch seine Termine storniert.
// Beide verlangen das AKTUELLE Passwort (vom Server geprüft).
// Zwei Formulare, daher zwei FormSubmit (zwei Fehlermengen). Wie
// beim Personenformular wird die Aktualisierung erst angezeigt, wenn
// das Konto gelesen wurde, und beginnt mit dessen Werten.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../api/rdvmedecins_api.dart';
import '../api/types.dart';
import '../state/cache.dart';
import '../state/messages.dart';
import '../state/session.dart';
import '../i18n/translations.dart';
import '../widgets/input_field.dart';
import '../widgets/person_fields.dart';
import '../widgets/confirmation.dart';
import '../widgets/form_submit.dart';
import '../widgets/page_title.dart';
class MyAccountPage extends StatefulWidget {
const MyAccountPage({super.key});
@override
State<MyAccountPage> createState() => _MyAccountPageState();
}
class _MyAccountPageState extends State<MyAccountPage> {
// bei jedem Besuch neu gelesen, ohne Cache: Seine Version muss aktuell sein
late final Future<MyAccount> _account = context.read<RdvMedecinsApi>().myAccount();
@override
Widget build(BuildContext context) {
return PageTitle(
titleKey: 'MY_ACCOUNT.TITLE',
child: ListView(
padding: const EdgeInsets.all(12),
children: [
FutureBuilder<MyAccount>(
future: _account,
builder: (context, state) => state.hasData
? _Update(account: state.data!)
: const Padding(
padding: EdgeInsets.all(24),
child: Center(child: CircularProgressIndicator()),
),
),
const _Deletion(),
],
),
);
}
}
// -------------------------------------------------------------------------
// 1. die Aktualisierung
// -------------------------------------------------------------------------
class _Update extends StatefulWidget {
final MyAccount account;
const _Update({required this.account});
@override
State<_Update> createState() => _UpdateState();
}
class _UpdateState extends State<_Update> {
late final _messages = context.read<Messages>();
late final _submit = FormSubmit(_messages);
late final Map<String, Object?> _input = {
'title': widget.account.title,
'firstName': widget.account.firstName,
'lastName': widget.account.lastName,
'login': widget.account.login,
'password': '',
'confirmation': '',
'currentPassword': '',
'version': widget.account.version,
};
@override
void dispose() {
_submit.dispose();
super.dispose();
}
void _edit(String field, String value) {
setState(() => _input[field] = value);
_submit.clearError(field);
}
Future<void> _save() async {
final api = context.read<RdvMedecinsApi>();
final session = context.read<Session>();
final cache = context.read<Cache>();
final succeeded = await _submit.submit(() async {
// der Server hat ein NEUES Token ausgestellt (Name, Login): Die obere Leiste muss folgen
session.update(await api.editMyAccount(_input));
_messages.flash(key: 'MY_ACCOUNT.UPDATED');
});
if (!mounted) return;
if (succeeded) {
cache.invalidate('my-area');
context.go('/my-area');
} else {
// niemals ein Passwort im Feld belassen nach einer abgelehnten Übermittlung;
// wir ändern den Wert OHNE Umweg über _edit(), um nicht
// den Fehler zu löschen, den der Server gerade daran angehängt hat
setState(() => _input['currentPassword'] = '');
}
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return ListenableBuilder(
listenable: _submit,
builder: (context, _) => Card(
child: Padding(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(t('MY_ACCOUNT.TITLE'), style: Theme.of(context).textTheme.titleLarge),
PersonFields(values: _input, errors: _submit.errors, onChanged: _edit),
const SizedBox(height: 12),
Text(t('PERSONS.ACCOUNT_SECTION'), style: Theme.of(context).textTheme.titleSmall),
InputField(
label: 'PERSONS.LOGIN_LABEL',
maxLength: 30,
value: _input['login'] as String,
onChanged: (v) => _edit('login', v),
error: _submit.errors['login'],
),
InputField(
label: 'MY_ACCOUNT.NEW_PASSWORD_LABEL',
secret: true,
maxLength: 72,
value: _input['password'] as String,
onChanged: (v) => _edit('password', v),
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,
onChanged: (v) => _edit('confirmation', v),
error: _submit.errors['confirmation'],
),
InputField(
label: 'MY_ACCOUNT.CURRENT_PASSWORD_LABEL',
secret: true,
maxLength: 72,
value: _input['currentPassword'] as String,
onChanged: (v) => _edit('currentPassword', v),
error: _submit.errors['currentPassword'],
help: 'MY_ACCOUNT.CURRENT_PASSWORD_HELP',
),
const SizedBox(height: 8),
Wrap(
spacing: 8,
children: [
FilledButton(onPressed: _submit.submitting ? null : _save, child: Text(t('PERSONS.SAVE'))),
OutlinedButton(onPressed: () => context.go('/my-area'), child: Text(t('MY_ACCOUNT.BACK'))),
],
),
],
),
),
),
);
}
}
// -------------------------------------------------------------------------
// 2. die Löschung: ein Formular mit einem einzigen Feld
// -------------------------------------------------------------------------
class _Deletion extends StatefulWidget {
const _Deletion();
@override
State<_Deletion> createState() => _DeletionState();
}
class _DeletionState extends State<_Deletion> {
late final _messages = context.read<Messages>();
late final _submit = FormSubmit(_messages);
String _currentPassword = '';
@override
void dispose() {
_submit.dispose();
super.dispose();
}
Future<void> _delete() async {
final api = context.read<RdvMedecinsApi>();
final session = context.read<Session>();
if (!await confirm(context, 'MY_ACCOUNT.DELETE_CONFIRM')) return;
final succeeded = await _submit.submit(() => api.deleteMyAccount(_currentPassword));
if (succeeded) {
// zuerst die Meldung: Sie wird auf dem Login-Bildschirm angezeigt, wohin
// uns der Router bringt, sobald die Sitzung leer ist
_messages.flash(key: 'MY_ACCOUNT.DELETED');
session.forget(voluntary: true); // der Server hat das Token-Cookie gelöscht
}
}
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return ListenableBuilder(
listenable: _submit,
builder: (context, _) => Card(
shape: RoundedRectangleBorder(
side: BorderSide(color: Colors.red.shade300),
borderRadius: BorderRadius.circular(12),
),
child: Padding(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(
t('MY_ACCOUNT.DELETE_TITLE'),
style: Theme.of(context).textTheme.titleLarge!.copyWith(color: Colors.red.shade700),
),
Text(t('MY_ACCOUNT.DELETE_HELP'), style: const TextStyle(color: Colors.grey)),
InputField(
label: 'MY_ACCOUNT.CURRENT_PASSWORD_LABEL',
secret: true,
maxLength: 72,
value: _currentPassword,
onChanged: (v) {
setState(() => _currentPassword = v);
_submit.clearError('currentPassword');
},
error: _submit.errors['currentPassword'],
),
Align(
alignment: Alignment.centerLeft,
child: FilledButton(
style: FilledButton.styleFrom(backgroundColor: Colors.red.shade700),
onPressed: _submit.submitting ? null : _delete,
child: Text(t('MY_ACCOUNT.DELETE_SUBMIT')),
),
),
],
),
),
),
);
}
}
|
„Mein Konto verwalten“: zwei voneinander unabhängige Formulare, jedes mit seinem eigenen [FormSubmit].
- Zeile 38: das Konto, bei jedem Besuch ohne Cache neu geladen (seine Version muss aktuell sein);
- Zeilen 100–117: die Änderung. Der Server gibt den aktualisierten Benutzer zurück (und ein neues Token in dessen Cookie): Die Sitzung wird aktualisiert, und der im Menü angezeigte Name wird entsprechend angepasst. Nach einer Ablehnung wird das aktuelle Passwort aus dem Feld gelöscht;
- Zeilen 207–216: Löschen des Kontos, nach Bestätigung. Zuerst die Meldung (eine Pop-up-Meldung); dann wird die Sitzung gelöscht, und der Router zeigt den Anmeldebildschirm zusammen mit der Meldung an.
11.13.9. lib/pages/error_page.dart
| // =========================================================================
// lib/pages/error_page.dart - der Fehlerbildschirm: 404 (unbekannte Adresse) oder
// 403 (unzureichende Rolle, siehe router.dart)
// =========================================================================
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:provider/provider.dart';
import '../i18n/translations.dart';
import '../widgets/page_title.dart';
class ErrorPage extends StatelessWidget {
final int code; // 403 oder 404
const ErrorPage({super.key, required this.code});
@override
Widget build(BuildContext context) {
final t = context.watch<Translations>().t;
return PageTitle(
titleKey: 'ERROR_PAGE.TITLE',
child: Padding(
padding: const EdgeInsets.all(24),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'${t('ERROR_PAGE.TITLE')} $code',
style: Theme.of(context).textTheme.headlineMedium!.copyWith(color: Colors.red.shade700),
),
const SizedBox(height: 8),
Text(t(code == 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND')),
const SizedBox(height: 16),
FilledButton(onPressed: () => context.go('/'), child: Text(t('ERROR_PAGE.BACK'))),
],
),
),
);
}
}
|
Die Fehlerseite: 404 (unbekannte Adresse) oder 403 (unzureichende Rolle). „Zurück zur Startseite“ führt zu [/], was der Router auf die Startseite der Rolle umleitet.