5. Kapitel 4 - Der Flutter-Client für die Anwendung RdvMedecins
5.1. Überblick über die Architektur

Dieser Client kommuniziert mit dem [rdvmedecins-nestjs-server]-Server des Kurses – der unverändert bleibt – über dieselben HTTP-Routen, die bereits dokumentiert wurden (POST [/login], GET [/getAllDoctors], GET [/getAllClients], GET [/getDoctorScheduleOfDay/:doctorId/:day], POST [/addAppointment], POST [/deleteAppointment]), mit demselben JSON-Umschlag [{ status, data }] und derselben tokenbasierten Authentifizierung [JWT] (Header [Authorization: Bearer <token>]). Bei dieser Variante erhält die Gesamtarchitektur eine dritte Komponente: Je nach gewähltem Kompilierungsziel (siehe Kapitel 5) führt nicht mehr nur ein Browser den Client aus, sondern möglicherweise ein mobiles oder ein Desktop-Betriebssystem, das den kompilierten [Dart]-Code direkt ausführt – der Server [NestJS] verarbeitet unterdessen weiterhin nur dieselben HTTP-Anfragen, unabhängig vom Ziel.
5.2. Verzeichnisstruktur des Projekts

| rdvmedecins_flutter_client/
├── pubspec.yaml project configuration (dependencies, assets)
├── assets/
│ └── i18n/ translation dictionaries (fr.json, en.json)
└── lib/
├── main.dart entry point (builds the services, provides them, starts the app)
├── app.dart root widget (conductor + authentication guard)
├── core/
│ ├── models/ data classes (mirror of the JSON exchanged with the server)
│ ├── services/ SettingsService, AuthService, AppointmentService
│ ├── http/ AuthHttpClient (JWT token + logout on 401)
│ └── i18n/ TranslationsService (French/English)
└── features/ one widget per feature, including the login screen
|
Diese Verzeichnisstruktur entspricht Ordner für Ordner der des [Vue.js]-Clients dieses Kurses ([core/models], [core/composables] -> [core/services], [core/interceptors] -> [core/http], [features/] unverändert) – eine bewusste Entscheidung: Die Organisation einer Anwendung ist in den meisten Fällen nicht an ein bestimmtes UI-Framework gebunden.
5.3. Konfigurationsdateien des Projekts
5.3.1. pubspec.yaml
| name: rdvmedecins_flutter_client
description: >
Flutter client (mobile, desktop and web from one and the same source code)
for the RdvMedecins application - NestJS / Flutter port of this course.
publish_to: 'none'
version: 1.0.0+1
environment:
sdk: '>=3.4.0 <4.0.0'
flutter: '>=3.24.0'
dependencies:
flutter:
sdk: flutter
# http: der offizielle "Low-Level"-HTTP-Client des Dart-Ökosystems - das exakte
# Äquivalent des auf der Vue.js-Seite verwendeten fetch() (auth.interceptor.ts,
# appointment.service.ts). Flutter hat kein in die Sprache eingebautes fetch(): diese
# Bibliothek tritt an seine Stelle.
http: ^1.2.2
# provider: der verbreitetste Weg, einen GEMEINSAMEN Zustand für einen ganzen
# Flutter-Widget-Baum bereitzustellen - genau die Rolle von provide()/inject()
# auf der Vue.js-Seite (settings.composable.ts, auth.composable.ts,
# language.composable.ts). Siehe das Kapitel "Introduction to Flutter" für
# die detaillierte Entsprechung.
provider: ^6.1.2
# shared_preferences: ein persistenter Schlüssel-Wert-Speicher, der auf
# Mobilgeräten, Desktop UND Web auf die GLEICHE Weise verfügbar ist - das plattformübergreifende Äquivalent von
# localStorage (das seinerseits nur in einem Browser existiert).
shared_preferences: ^2.3.2
# intl: Datumsformatierung (yyyy-MM-dd, siehe DoctorDayPicker) - dieselbe
# Rolle wie Date.toISOString().slice(0, 10) auf der Vue.js/TypeScript-Seite, aber
# explizit statt eines bloßen Abschneidens des Strings.
intl: ^0.19.0
dev_dependencies:
flutter_test:
sdk: flutter
flutter_lints: ^4.0.0
flutter:
uses-material-design: true
# the translation dictionaries - the equivalent of public/i18n/*.json auf der
# Vue.js-Seite, aber in das Anwendungspaket EINGEBETTET, statt von
# einem Webserver ausgeliefert zu werden (siehe Kapitel "Porting the application" für den Grund
# für diesen Unterschied, der genau die 3 Zielumgebungen betrifft).
assets:
- assets/i18n/
|
Kommentieren wir diesen Code:
- Zeilen 9–10: [sdk: '>=3.4.0 <4.0.0'] / [flutter: '>=3.24.0'] – entspricht dem Feld [engines] einer [package.json] [Node.js]: dem Bereich der für dieses Projekt erforderlichen Versionen der Sprache [Dart] und des SDK [Flutter] .
- Zeilen 16–20, 22–27, 29–32, 34–37: die vier Abhängigkeiten dieses Clients, jeweils direkt mit ihrem [Vue.js]-Pendant kommentiert – siehe auch den Abschnitt „Verwendete Werkzeuge“ der Einleitung.
- Zeile 42: [flutter_lints: ^4.0.0] – das [Dart]-Gegenstück zu [ESLint]: ein Satz von Stil-/Qualitätsregeln, die von [flutter analyze] überprüft werden; er fehlte bei den früheren Web-Clients dieses Kurses, wurde aber automatisch von [flutter create] erzeugt.
- Zeilen 51–52: [assets: - assets/i18n/] – deklariert AUSDRÜCKLICH, dass der gesamte Inhalt von [assets/i18n/] in das Anwendungspaket eingebettet werden muss; ohne diese Deklaration würde [rootBundle.loadString(...)] (siehe [core/i18n/translations_service.dart] weiter unten) zur Laufzeit fehlschlagen – eine Datei, die zum Zeitpunkt von [flutter build] auf der Festplatte vorhanden ist, wird nicht automatisch in das endgültige Paket aufgenommen, anders als [public/] bei [Vite]/[Vue.js], das ohne vorherige Deklaration unverändert ausgeliefert wird.
5.4. Die Anwendung starten

5.4.1. lib/main.dart
Portierung von [src/main.ts] (Client [Vue.js]): erstellt die Services dieses Clients, stellt sie über [provider] dem gesamten Widget-Baum zur Verfügung und startet dann die Anwendung.
| // =========================================================================
// main.dart
// -------------------------------------------------------------------------
// Einstiegspunkt des Flutter-Clients. Äquivalent von src/main.ts auf der Vue.js-
// Client-Seite dieses Kurses: Diese Datei startet die Anwendung explizit
// (hier runApp(...); auf der Vue.js-Seite createApp(...).mount(...)) UND
// konfiguriert sie.
//
// Vue.js konfiguriert seine Anwendung mit app.provide(key, value), direkt auf der
// Anwendungsinstanz aufgerufen - Flutter/provider verwendet
// stattdessen ein Widget, MultiProvider, das an der Wurzel des Baums platziert wird (siehe runApp(...)
// weiter unten): Jeder darin enthaltene ChangeNotifierProvider/Provider stellt
// eine Instanz für den GESAMTEN Teilbaum bereit, den er umschließt, genau
// wie app.provide(...) es für alle untergeordneten Komponenten tat -
// dieselbe Idee, ausgedrückt als WIDGET statt als imperativer
// Methodenaufruf, denn in Flutter ist ALLES ein Widget (auch
// die Konfiguration eines gemeinsamen Zustands).
//
// Die REIHENFOLGE der Konstruktionen ist weiterhin wichtig, aus denselben Gründen wie
// auf der Vue.js-Seite: AuthService(settings) braucht ein bereits existierendes settings
// (um apiBaseUrl zu lesen); AppointmentService braucht authHttp UND settings.
//
// WICHTIGER UNTERSCHIED zu Vue.js: createAuthStore(settings) und
// createLanguageStore() auf der Vue.js-Seite lesen localStorage SYNCHRON
// während ihrer Konstruktion, noch vor dem ersten Rendern. Ihre
// Flutter-Entsprechungen (AuthService.init(), TranslationsService.init())
// sind ASYNCHRON (siehe die jeweiligen Dateien): main() selbst muss
// daher eine async-Funktion werden und auf diese beiden
// Initialisierungen WARTEN (await), BEVOR runApp(...) aufgerufen wird - andernfalls würde der erste
// angezeigte Bildschirm eine eventuell bereits gespeicherte Sitzung oder Sprache ignorieren,
// solange shared_preferences noch nicht geantwortet hat.
//
// Wie die Angular-, React- und Vue.js-Clients dieses Kurses (eine einzige Seite,
// keine Routing-Tabelle) verwendet dieser Flutter-Client NUR die minimale
// Navigation von MaterialApp (unverzichtbar für showDialog(), siehe
// features/booking_dialog/booking_dialog.dart): AppRoot (siehe app.dart)
// zeigt je nach AuthService.isLoggedIn entweder den Anmeldebildschirm oder den Rest der Anwendung an
// - ein einfaches Dart-if/else genügt, ein Routing-Paket
// (go_router oder ein anderes) hätte für eine Anwendung
// mit nur einem Bildschirm nichts gebracht.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'app.dart';
import 'core/http/auth_http_client.dart';
import 'core/i18n/translations_service.dart';
import 'core/services/auth_service.dart';
import 'core/services/appointment_service.dart';
import 'core/services/settings_service.dart';
Future<void> main() async {
// WidgetsFlutterBinding.ensureInitialized(): unverzichtbar, sobald man
// eine Flutter-API VOR runApp(...) aufruft (hier shared_preferences und
// rootBundle.loadString(...) in TranslationsService.init()) - ohne
// diese Zeile würden diese Aufrufe beim Start fehlschlagen. Vue.js kennt nichts
// Vergleichbares: Der Browser ist immer "bereit", noch bevor
// src/main.ts ausgeführt wird.
WidgetsFlutterBinding.ensureInitialized();
// 1. Zuerst SettingsService: AuthService und AppointmentService brauchen ihn
// (apiBaseUrl).
final settings = SettingsService();
// 2. AuthService: erhält settings direkt im Konstruktor, wie
// createAuthStore(settingsStore) auf der Vue.js-Seite - anschließend stellt init() eine
// eventuell gespeicherte Sitzung wieder her (siehe den Kopfkommentar
// oben zur Asynchronität dieses Schritts).
final auth = AuthService(settings);
await auth.init();
// 3. die authentifizierte HTTP-Schicht, dann der Geschäftsservice - beide
// HIER gebaut, nur einmal, statt innerhalb eines Widgets
// (wo sie bei jedem Rendern neu gebaut würden): genau dasselbe
// Prinzip wie createSettingsStore()/createAuthStore(...), die auf der Vue.js-Seite nur
// einmal vor app.mount(...) aufgerufen werden.
final authHttp = AuthHttpClient(auth);
final api = AppointmentService(authHttp, settings);
// 4. TranslationsService: lädt das Start-Wörterbuch (die
// gespeicherte Sprache oder standardmäßig die Sprache des Geräts) - KEINE Reihenfolgeabhängigkeit
// von den vorherigen Schritten (anders als
// createLanguageStore() auf der Vue.js-Seite, das auf
// app.use(i18n) warten musste: Diese Datei implementiert alles selbst, siehe
// core/i18n/translations_service.dart, es muss also kein
// Plugin eines Drittanbieters installiert werden, bevor man es verwenden kann).
final translations = TranslationsService();
await translations.init();
runApp(
// MultiProvider: fasst mehrere Provider in einem einzigen Widget zusammen,
// statt sie von Hand zu verschachteln (Provider(...) > Provider(...)
// > Provider(...) > ...) - eine Lesbarkeit, vergleichbar mit der Abfolge
// der Aufrufe "app.provide(SettingsKey, ...); app.provide(AuthKey, ...);
// app.provide(LanguageKey, ...);" auf der Vue.js-Seite, trotz des Unterschieds
// in der Form (eine Liste von Widgets statt einer Folge von Anweisungen).
MultiProvider(
providers: [
// .value(...) statt Provider(create: ...): Diese Instanzen
// existieren bereits (oben gebaut) - .value(...) stellt sie lediglich
// dem Widget-Baum bereit, ohne
// neue zu bauen. ChangeNotifierProvider abonniert zudem
// notifyListeners() und zeichnet automatisch jedes
// Widget neu, das context.watch<...>() auf diesem Provider aufgerufen hat (siehe
// lib/app.dart) - die Rolle, die auf der Vue.js-Seite die "reaktive" Natur eines
// reactive(...) spielt.
ChangeNotifierProvider.value(value: settings),
ChangeNotifierProvider.value(value: auth),
ChangeNotifierProvider.value(value: translations),
// AppointmentService ist KEIN ChangeNotifier (in diesem Service ändert sich nach dem Bau
// nichts mehr im Lauf der Zeit): Ein einfacher Provider
// genügt, er stellt nur diese Instanz bereit, ohne
// jeden Benachrichtigungsmechanismus.
Provider.value(value: api),
],
child: const RdvMedecinsApp(),
),
);
}
|
Kommentieren wir diesen Code:
- Zeile 60: [WidgetsFlutterBinding.ensureInitialized();] – erforderlich, sobald Sie eine [Flutter]-API VOR [runApp(...)] aufrufen (hier [shared_preferences] und [rootBundle.loadString(...)]) – ohne diese Zeile würden diese Aufrufe beim Start fehlschlagen; [Vue.js] muss nichts Derartiges berücksichtigen, da der Browser stets „bereit“ ist, noch bevor [src/main.ts] ausgeführt wird.
- Zeilen 70–71: [final auth = AuthService(settings); await auth.init();] – GROSSER UNTERSCHIED zu [createAuthStore(settingsStore)] auf der Seite von [Vue.js], das [localStorage] SYNCHRON liest, sobald es erstellt wird: [AuthService.init()] ist ausdrücklich [async], und [main()] muss daher selbst ebenfalls asynchron sein, um vor [runApp(...)] WARTEN zu können – andernfalls würde der erste angezeigte Bildschirm eine bereits gespeicherte Sitzung ignorieren, während er auf die Antwort von [shared_preferences] wartet.
- Zeile 89: [await translations.init();] – derselbe Hinweis wie oben zur gespeicherten Sprache; anders als [createLanguageStore()] bei [Vue.js], das auf [app.use(i18n)] warten musste, hat dieser Schritt keine sequenzielle Abhängigkeit von den vorherigen: [TranslationsService] implementiert alles selbst, ohne dass vorher ein Drittanbieter-Plugin installiert werden müsste.
- Zeilen 98–116: [MultiProvider(providers: [...], child: const RdvMedecinsApp())] – das Pendant, in Form eines WIDGETS statt imperativer Aufrufe, zur Sequenz [app.provide(SettingsKey, ...); app.provide(AuthKey, ...); app.provide(LanguageKey, ...);] auf der Seite von [Vue.js]: Jeder [ChangeNotifierProvider.value(...)] stellt eine vorab erstellte Instanz dem gesamten Teilbaum zur Verfügung.
5.4.2. lib/app.dart
Portierung von [src/app/App.vue]: das WURZEL-Widget der Anwendung (erstellt von [lib/main.dart]) – der „Dirigent“, der den fachlichen Zustand hält und auf Aktionen der Widgets in [lib/features/] reagiert, sowie der „Guard“ für die Authentifizierung.
| // =========================================================================
// app.dart
// -------------------------------------------------------------------------
// Port von src/app/App.vue (Vue.js-Client dieses Kurses): das ROOT-
// Widget der Anwendung (von lib/main.dart gebaut). Wie in den
// drei anderen Varianten dieses Kurses spielt es die Rolle des
// "Dirigenten": Es hält den Anwendungszustand (Ärzte, Clients,
// angezeigter Terminkalender, zuletzt gesuchter Arzt/Tag...) und reagiert auf die Aktionen
// der "Geschäfts"-Widgets in lib/features/, um den NestJS-Server im
// richtigen Moment über AppointmentService aufzurufen.
//
// Seit der Einführung der Authentifizierung spielt dieses Widget zudem die Rolle des
// "Guards": Solange AuthService.isLoggedIn false ist, zeigt es nur
// LoginPage an (siehe lib/features/login/); da alle Server-Routen
// durch JwtAuthGuard geschützt sind, wäre es ohnehin nutzlos (und eine Quelle
// von 401-Fehlern), Ärzte/Clients/Terminkalender zu laden, bevor man angemeldet ist.
//
// Zwei Klassen, wie in den anderen "zustandsbehafteten" Dateien dieses Clients:
// RdvMedecinsApp (die MaterialApp - die ABSOLUTE Wurzel, siehe lib/main.dart) und
// AppRoot/_AppRootState (das eigentliche Äquivalent von App.vue, mit seinem gesamten Zustand).
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'core/i18n/translations_service.dart';
import 'core/models/appointment_models.dart';
import 'core/services/auth_service.dart';
import 'core/services/appointment_service.dart';
import 'core/services/settings_service.dart';
import 'features/schedule/schedule_view.dart';
import 'features/booking_dialog/booking_dialog.dart';
import 'features/doctor_day_picker/doctor_day_picker.dart';
import 'features/login/login_page.dart';
// -------------------------------------------------------------------------
// RdvMedecinsApp: die Flutter-Wurzel im strengen Sinn - MaterialApp liefert
// das Theme, die Navigation (Navigator, verwendet von showDialog(), siehe
// features/booking_dialog/booking_dialog.dart) und die Systemübersetzungen
// (Scrollen, Dialogfelder...). Es entspricht, sehr
// grob, dem, was index.html + die Einbindung app.mount('#app')
// zusammen auf der Vue.js-Seite (src/main.ts) taten - nur dass diese
// "Hülle" hier selbst Teil des Dart-Codes der Anwendung ist, statt
// einer separaten HTML-Datei.
// -------------------------------------------------------------------------
class RdvMedecinsApp extends StatelessWidget {
const RdvMedecinsApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
debugShowCheckedModeBanner: false,
// explizites appBarTheme: Das Standard-Theme von Material 3 gibt
// AppBar einen hellen Hintergrund (colorScheme.surface) - um die blaue Leiste mit weißem Text
// von "navbar navbar-dark bg-primary" auf der
// Vue.js-Seite (siehe App.vue) wiederzubekommen, werden Hintergrund und Text hier explizit gesetzt,
// statt auf jedem einzelnen
// Text() von AppRoot unten eine Textfarbe fest zu codieren (siehe auth.name, weiter unten) - eine
// einzige Quelle der Wahrheit für das Aussehen der Leiste.
theme: ThemeData(
colorSchemeSeed: Colors.blue,
useMaterial3: true,
appBarTheme: const AppBarTheme(
backgroundColor: Colors.blue,
foregroundColor: Colors.white,
),
),
home: const AppRoot(),
);
}
}
class AppRoot extends StatefulWidget {
const AppRoot({super.key});
@override
State<AppRoot> createState() => _AppRootState();
}
class _AppRootState extends State<AppRoot> {
// — Anwendungszustand —————————————
// das direkte Äquivalent der ref(...) von App.vue, als einfache
// veränderliche Felder von _AppRootState: setState(...) (siehe die Methoden
// unten) ersetzt die automatische Reaktivität von Vue.js.
List<Doctor> _doctors = [];
List<Client> _clients = [];
DoctorDaySchedule? _schedule;
String? _error;
// Die letzte Suche (Arzt + Tag) wird gemerkt, um den Terminkalender nach einer Buchung oder einer Stornierung
// aktualisieren zu können - dieselbe
// Rolle wie lastDoctorId/lastDay auf der Vue.js-Seite.
int? _lastDoctorId;
String? _lastDay;
// dauerhaft gehaltene Referenz auf AuthService, um sich in dispose() sauber
// abmelden zu können (siehe unten) - den Grund für diese Wahl nennt
// der Kommentar von initState() weiter unten.
late final AuthService _auth;
@override
void initState() {
super.initState();
// context.read<AuthService>(): Wenn initState() läuft, ist das
// Widget bereits ordnungsgemäß in den Baum eingefügt (anders als im
// Konstruktor, wo context noch nicht für
// Dependency Injection verwendet werden kann) - aber context.watch(...) wird hier NICHT verwendet:
// Ein StatefulWidget darf einen Provider nur einmal abonnieren,
// explizit, niemals innerhalb von initState() mit watch()
// (das einen Build-Kontext voraussetzt). Daher wird die Referenz in
// einem Feld (_auth) gehalten, und wir abonnieren selbst mit addListener(...).
_auth = context.read<AuthService>();
_auth.addListener(_onAuthChange);
// Äquivalent von "watch(() => auth.isLoggedIn, ..., { immediate: true })"
// auf der Vue.js-Seite: { immediate: true } löst den Callback
// SOFORT aus, ohne auf eine erste Änderung zu warten - nützlich, falls bereits eine Sitzung
// gespeichert war (siehe AuthService.init(), das von
// lib/main.dart vor runApp(...) abgewartet wird). Vue.js bietet diese Option
// direkt an; Flutter hat in addListener(...) keinen
// eingebauten entsprechenden Mechanismus, daher wird derselbe Effekt VON HAND nachgebildet: ein
// expliziter Aufruf direkt nach dem Abonnieren, zusätzlich zum Abonnement
// selbst.
if (_auth.isLoggedIn) {
_loadInitialLists();
}
}
@override
void dispose() {
// Das Abmelden ist hier ESSENZIELL: Ohne es würde _onAuthChange
// weiter aufgerufen, nachdem dieses Widget zerstört wurde (zum
// Beispiel bei einem Hot Reload oder einem Routenwechsel), und
// würde beim ersten setState(...) auf einem
// nicht eingebundenen Widget eine Exception auslösen. Vue.js kennt hier nichts Vergleichbares: watch(...) wird
// automatisch "aufgeräumt", wenn die Komponente, die es erzeugt hat, zerstört wird.
_auth.removeListener(_onAuthChange);
super.dispose();
}
void _onAuthChange() {
if (_auth.isLoggedIn) {
_loadInitialLists();
}
}
// -----------------------------------------------------------------------
// Wenn wir angemeldet sind (erfolgreiche Anmeldung oder aus
// shared_preferences wiederhergestellte Sitzung), werden die Listen der Ärzte und Clients
// ein für alle Mal geladen.
// -----------------------------------------------------------------------
void _loadInitialLists() {
final api = context.read<AppointmentService>();
api.getAllDoctors().then((result) {
if (mounted) setState(() => _doctors = result);
}).catchError((Object err) {
if (mounted) setState(() => _error = err.toString());
});
api.getAllClients().then((result) {
if (mounted) setState(() => _clients = result);
}).catchError((Object err) {
if (mounted) setState(() => _error = err.toString());
});
}
// -----------------------------------------------------------------------
// reagiert auf den Button "Log out": löscht die Sitzung UND den angezeigten Geschäftszustand - ohne dies
// würde ein danach angemeldeter neuer Benutzer kurzzeitig
// den Terminkalender des vorherigen sehen.
// -----------------------------------------------------------------------
Future<void> _onLogout() async {
await _auth.logOut();
setState(() {
_doctors = [];
_clients = [];
_schedule = null;
_error = null;
_lastDoctorId = null;
_lastDay = null;
});
}
// -----------------------------------------------------------------------
// reagiert auf den Aufruf von onSearch(...) durch das Widget DoctorDayPicker
// -----------------------------------------------------------------------
void _onSearchSchedule(int doctorId, String day) {
setState(() {
_error = null;
_lastDoctorId = doctorId;
_lastDay = day;
});
_loadSchedule();
}
// -----------------------------------------------------------------------
// reagiert auf den Aufruf von onBook(...) durch das Widget ScheduleView: HIER wird, anders als bei
// Vue.js (das lediglich das Fenster öffnete,
// während es slotBeingBooked merkte), das Dialogfeld DIREKT
// mit showDialog (über openBookingDialog(...)) geöffnet und sein Ergebnis
// ABGEWARTET - Details zu diesem strukturellen Unterschied siehe
// den Kopf von booking_dialog.dart.
// -----------------------------------------------------------------------
Future<void> _onBookingRequest(SlotJson slot) async {
final lastDay = _lastDay;
if (lastDay == null) {
return;
}
final clientId = await openBookingDialog(context: context, slot: slot, clients: _clients);
if (clientId == null) {
return; // Der Benutzer hat das Dialogfeld geschlossen, ohne einen Patienten zu wählen
}
try {
await context.read<AppointmentService>().addAppointment(lastDay, clientId, slot.id);
_loadSchedule(); // Der Terminkalender wird aktualisiert: Der Slot erscheint nun als gebucht
} catch (err) {
if (mounted) setState(() => _error = err.toString());
}
}
// -----------------------------------------------------------------------
// reagiert auf den Aufruf von onCancel(...) durch das Widget ScheduleView
// -----------------------------------------------------------------------
Future<void> _onCancelAppointment(AppointmentJson appointment) async {
try {
await context.read<AppointmentService>().deleteAppointment(appointment.id);
_loadSchedule(); // Der Terminkalender wird aktualisiert: Der Slot ist wieder frei
} catch (err) {
if (mounted) setState(() => _error = err.toString());
}
}
void _loadSchedule() {
final doctorId = _lastDoctorId;
final day = _lastDay;
if (doctorId == null || day == null) {
return;
}
context.read<AppointmentService>().getDoctorScheduleOfDay(doctorId, day).then((result) {
if (mounted) setState(() => _schedule = result);
}).catchError((Object err) {
if (mounted) setState(() => _error = err.toString());
});
}
@override
Widget build(BuildContext context) {
// context.watch<...>() auf den DREI Providern, von denen die Anzeige
// direkt abhängt: Jeder Aufruf abonniert dieses Widget für die künftigen Änderungen
// des jeweiligen Providers - benachrichtigt einer von ihnen (notifyListeners()), wird build(...)
// automatisch erneut aufgerufen. Dies ist der Mechanismus, der hier
// die automatische Reaktivität von Vue.js ersetzt, die in
// core/services/settings_service.dart erwähnt wurde.
final t = context.watch<TranslationsService>().t;
final language = context.watch<TranslationsService>();
final auth = context.watch<AuthService>();
final settings = context.watch<SettingsService>();
// schmaler Bildschirm (Smartphone im Hochformat): Die Titelleiste wird abgespeckt
// (siehe actions: unten), da der Platz fehlt, um alles anzuzeigen, was
// auf einem breiten Bildschirm problemlos hineinpasst.
final narrow = MediaQuery.sizeOf(context).width < 600;
return Scaffold(
appBar: AppBar(
title: Text(t('APP.TITLE')),
actions: [
// FR/EN-Auswahl: IMMER sichtbar (auch auf dem Anmeldebildschirm) - das
// Gegenstück zum <div class="btn-group">, das in App.vue immer
// angezeigt wird.
SegmentedButton<String>(
segments: const [
ButtonSegment(value: 'fr', label: Text('FR')),
ButtonSegment(value: 'en', label: Text('EN')),
],
selected: {language.currentLanguage},
onSelectionChanged: (choice) => language.changeLanguage(choice.first),
showSelectedIcon: false,
),
const SizedBox(width: 12),
// Rollen-Badge + Name + Abmelde-Button hingegen werden
// erst nach der Anmeldung angezeigt (auth.isLoggedIn) - dieselbe
// Bedingung wie beim <template v-if="auth.isLoggedIn"> in App.vue.
if (auth.isLoggedIn) ...[
Chip(label: Text(auth.role?.asString() ?? '')),
const SizedBox(width: 8),
// kein fest codierter Farbstil hier: Dieser Text() erbt die
// weiße foregroundColor aus appBarTheme (siehe RdvMedecinsApp
// oben), genau wie "navbar-dark" auf der Bootstrap-Seite
// standardmäßig seinen gesamten Inhalt weiß färbte.
// Auf einem schmalen Bildschirm wird der Name ausgeblendet: Rollen-Badge und Abmelde-Button
// genügen, und die Titelleiste passt in die Breite.
if (!narrow) Text(auth.name ?? ''),
IconButton(
tooltip: t('APP.LOGOUT'),
icon: const Icon(Icons.logout),
onPressed: _onLogout,
),
],
const SizedBox(width: 8),
],
),
body: SafeArea(
child: SingleChildScrollView(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
// Server-URL: sowohl vor als auch nach der Anmeldung nützlich -
// ausgelagert in ein kleines dediziertes privates Widget, _ServerUrlField
// (siehe unten), aus den Gründen, die bei seiner
// Definition erläutert werden.
ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 320),
child: _ServerUrlField(settings: settings, label: t('APP.SERVER_URL_LABEL')),
),
const SizedBox(height: 16),
if (_error != null) ...[
Container(
width: double.infinity,
padding: const EdgeInsets.all(12),
decoration: BoxDecoration(
color: Theme.of(context).colorScheme.errorContainer,
borderRadius: BorderRadius.circular(4),
),
child: Text(
_error!,
style: TextStyle(color: Theme.of(context).colorScheme.onErrorContainer),
),
),
const SizedBox(height: 16),
],
// nicht angemeldet: nichts als der Anmeldebildschirm -
// das exakte Äquivalent von "<Login v-if="!auth.isLoggedIn" />"
// auf der Vue.js-Seite.
if (!auth.isLoggedIn)
const LoginPage()
else ...[
// Widget 1: Auswahl des Arztes und des Tages
DoctorDayPicker(doctors: _doctors, onSearch: _onSearchSchedule),
const SizedBox(height: 16),
// Widget 2: Anzeige des Terminkalenders - canEdit blendet
// "Book"/"Cancel" für eine Rolle USER aus
ScheduleView(
schedule: _schedule,
canEdit: auth.isAdmin,
onBook: _onBookingRequest,
onCancel: _onCancelAppointment,
),
],
],
),
),
),
);
}
}
// -------------------------------------------------------------------------
// _ServerUrlField: ein kleines PRIVATES StatefulWidget für das Feld "Server
// URL". Auf der Vue.js-Seite passt dieses Feld in eine einzige Zeile, direkt
// im <template> von App.vue (<input v-model="settings.apiBaseUrl">):
// v-model selbst übernimmt im Hintergrund die Synchronisierung zwischen dem
// angezeigten Feld und settings.apiBaseUrl. Flutter hat kein in TextField
// eingebautes Two-Way-Binding (siehe bereits lib/features/login/login_page.dart):
// es braucht einen TextEditingController und damit einen Besitzer, der ihn erzeugen
// und freigeben kann (initState/dispose) - ein an einen Provider gebundener EDITIERBARER TEXT kann in Flutter NICHT
// ein einfaches StatelessWidget sein, anders als
// ein entsprechendes Vue.js-Feld, das keine separate
// "Komponente" braucht, um zu existieren.
// -------------------------------------------------------------------------
class _ServerUrlField extends StatefulWidget {
final SettingsService settings;
final String label;
const _ServerUrlField({required this.settings, required this.label});
@override
State<_ServerUrlField> createState() => _ServerUrlFieldState();
}
class _ServerUrlFieldState extends State<_ServerUrlField> {
late final TextEditingController _controller;
@override
void initState() {
super.initState();
_controller = TextEditingController(text: widget.settings.apiBaseUrl);
}
@override
void dispose() {
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return TextField(
controller: _controller,
decoration: InputDecoration(labelText: widget.label, isDense: true),
// onChanged statt onSubmitted: Jeder Tastendruck wird
// sofort an SettingsService weitergegeben, genau wie
// v-model es auf der Vue.js-Seite für jedes getippte Zeichen tut (nicht nur
// beim Absenden des Formulars).
onChanged: widget.settings.setApiBaseUrl,
);
}
}
|
Kommentieren wir diesen Code:
- Zeilen 46–71: [class RdvMedecinsApp extends StatelessWidget] – die Wurzel [Flutter] im strengen Sinne: [MaterialApp] stellt Theme und Navigation bereit (unerlässlich für [showDialog(...)], siehe [booking_dialog.dart] weiter unten) – ungefähr das, was [index.html] + [app.mount('#app')] zusammen auf der Seite von [Vue.js] leisteten.
- Zeilen 60–66: [appBarTheme: const AppBarTheme(backgroundColor: Colors.blue, foregroundColor: Colors.white)] – bildet das Erscheinungsbild von ["navbar navbar-dark bg-primary"] ([Bootstrap], siehe [App.vue]) nach: Ein standardmäßiges [Material 3]-Theme würde [AppBar] einen hellen Hintergrund geben, daher muss er ausdrücklich gesetzt werden, um das vertraute blaue Banner mit weißem Text wiederherzustellen.
- Zeilen 96–127: [initState()] – bildet VON HAND das Pendant zu [watch(() => auth.isLoggedIn, ..., { immediate: true })] auf der Seite von [Vue.js] nach (siehe [App.vue]): [Flutter] hat keine in [immediate] eingebaute Option bei [addListener(...)], daher müssen Sie ZUERST einen Listener registrieren und DANN den aktuellen Status einmal ausdrücklich prüfen – zwei Schritte, wo [Vue.js] nur einen benötigt.
- Zeilen 129–139: [dispose() { _auth.removeListener(_onAuthChange); }] — UNVERZICHTBAR: Ohne dieses Abmelden würde [_onAuthChange] nach dem Zerstören des Widgets weiterhin aufgerufen und beim ersten Aufruf von [setState(...)] auf einem abgebauten Widget eine Ausnahme auslösen. [Vue.js] kennt nichts Vergleichbares, das man vorwegnehmen müsste, da [watch(...)] automatisch „aufgeräumt“ wird, sobald die Komponente, die es erstellt hat, zerstört wird.
- Zeilen 203–218: [_onBookingRequest(...)] — HIER liegt der sichtbarste strukturelle Unterschied dieses gesamten Clients: Anstatt ein „Fenster“ zu öffnen, indem ein boolescher Zustand gespeichert wird (siehe [slotBeingBooked] auf der Seite von [Vue.js]), wartet dieses Widget direkt mit [await] auf das Ergebnis von [openBookingDialog(...)] – siehe den vollständigen Kommentar in [booking_dialog.dart], weiter hinten in diesem Kapitel.
- Zeilen 253–256: vier [context.watch<...>()] am Anfang von [build(...)] – dieses Widget wird automatisch neu gezeichnet, sobald einer dieser vier Services (IRGENDEINER davon) eine Änderung meldet ([notifyListeners()]), genau die Rolle, die die automatische Reaktivität von [Vue.js] für [auth], [settings] und [language] in [App.vue] übernimmt.
- Zeilen 260 und 291: [MediaQuery.sizeOf(context).width < 600] – die Breite des Bildschirms (oder Fensters) wird verwendet, um die Titelleiste auf einem Smartphone im Hochformat zu entlasten: Der Name des Benutzers wird ausgeblendet ([if (!narrow) Text(...)], ein einfaches [if] in Dart mitten in einer Liste von Widgets), während das Rollen-Badge und die Abmeldeschaltfläche sichtbar bleiben. In Zeile 276 entfernt [showSelectedIcon: false] das Häkchen, das [SegmentedButton] der ausgewählten Option hinzufügt und das die Auswahl [FR]/[EN] unnötig verbreiterte. Ohne diese beiden Anpassungen [actions:] würden die Elemente der [AppBar] die Breite eines Smartphones im Hochformat überschreiten.
- Zeilen 359–409: [class _ServerUrlField] – ein kleines PRIVATES [StatefulWidget] für das Feld „Server-URL“. Bei [Vue.js] passte dieses Feld in eine einzige Zeile ([<input v-model="settings.apiBaseUrl">]): [Flutter] bietet bei [TextField] keine integrierte bidirektionale Bindung, daher ist ein [TextEditingController] erforderlich, zusammen mit einem Besitzer, der ihn erstellen und freigeben kann – ein editierbarer, an einen Provider gebundener Text kann in [Flutter] nicht einfach ein [StatelessWidget] sein.
5.5. Die Schicht core/models

5.5.1. lib/core/models/appointment_models.dart
Portierung von [core/models/appointment.models.ts], die selbst wörtlich aus den Clients [Angular] und [React] übernommen wurde: die Klassen, die das Format der mit dem Server ausgetauschten JSON-Daten beschreiben, ohne Abhängigkeiten zu [Flutter] – das „reine“ [Dart].
| // =========================================================================
// core/models/appointment_models.dart
// -------------------------------------------------------------------------
// Port von core/models/appointment.models.ts (Vue.js-Client dieses Kurses), das seinerseits
// unverändert aus den Angular- und React-Clients kopiert wurde: die Dart-Klassen, die
// die Form der vom NestJS-Server empfangenen JSON-Daten beschreiben. Wie ihre
// TypeScript-Gegenstücke hängen diese Klassen von keinem UI-Framework ab
// (hier kein Flutter-Import) - das ist "reines" Dart, so wie
// appointment.models.ts "reines" TypeScript war.
//
// STRUKTURELLER UNTERSCHIED zu TypeScript: Ein TypeScript-"interface" ist
// eine bloße Beschreibung einer FORM, die nur zur Kompilierzeit geprüft wird -
// zur Laufzeit wird ein dekodiertes JSON-Objekt (JSON.parse) UNVERÄNDERT verwendet,
// ohne Umwandlung, und TypeScript "vertraut" dem Entwickler (siehe das
// "as ServerResponse<T>" in appointment.service.ts). Dart kennt keinen solchen Begriff impliziter
// struktureller Typisierung: jsonDecode(...) liefert immer dynamische
// Typen (Map<String, dynamic>, List<dynamic>...), die
// explizit über einen Konstruktor fromJson(...) in Instanzen von Dart-Klassen umgewandelt werden müssen -
// vorhanden in JEDER der folgenden Klassen. Das ist einmalig aufwendiger zu schreiben,
// aber die Umwandlung wird zur Laufzeit geprüft
// (ein fehlender Schlüssel oder einer vom falschen Typ löst sofort eine explizite
// Exception aus), während eine falsche TypeScript-Typisierung unbemerkt bleiben kann.
// =========================================================================
// -------------------------------------------------------------------------
// Hülle (Envelope), die allen Serverantworten gemeinsam ist (siehe ServerResponse<T> auf der
// NestJS-Seite und das Interface ServerResponse<T> des Vue.js-Clients).
//
// Dart verallgemeinert ebenfalls mit spitzen Klammern (<T>), genau wie
// TypeScript - der große Unterschied ist, dass hier ein bloßes "as T" nicht
// genügt, um das Feld [data] umzuwandeln: Die Funktion, die aus rohem JSON ein T
// bauen kann, muss mitgegeben werden (der Parameter [parseData]
// unten), da Dart T zur Laufzeit nicht kennt
// (Type Erasure verhindert, direkt "T.fromJson(...)"
// zu schreiben).
// -------------------------------------------------------------------------
class ServerResponse<T> {
final int status; // 0 = Erfolg, alles andere = Fehler (siehe ResponseStatus auf der Serverseite)
final T? data;
ServerResponse({required this.status, required this.data});
factory ServerResponse.fromJson(
Map<String, dynamic> json,
T Function(dynamic rawData) parseData,
) {
final rawData = json['data'];
return ServerResponse<T>(
status: json['status'] as int,
data: rawData == null ? null : parseData(rawData),
);
}
}
class Doctor {
final int id;
final String title;
final String lastName;
final String firstName;
Doctor({required this.id, required this.title, required this.lastName, required this.firstName});
factory Doctor.fromJson(Map<String, dynamic> json) => Doctor(
id: json['id'] as int,
title: json['title'] as String,
lastName: json['lastName'] as String,
firstName: json['firstName'] as String,
);
}
// [Client] bedeutet hier einen PATIENTEN der Arztpraxis (Vokabular der
// Fachdomäne, übernommen aus dem Originaldokument) - nicht zu verwechseln mit
// "HTTP-Client" und auch nicht mit diesem Flutter-Client selbst!
class Client {
final int id;
final String title;
final String lastName;
final String firstName;
Client({required this.id, required this.title, required this.lastName, required this.firstName});
factory Client.fromJson(Map<String, dynamic> json) => Client(
id: json['id'] as int,
title: json['title'] as String,
lastName: json['lastName'] as String,
firstName: json['firstName'] as String,
);
}
// "leichte" Form eines Zeit-Slots, wie vom Server geliefert
// (siehe getMapForSlot auf der NestJS-Seite): nur die für die Anzeige nützlichen Felder.
class SlotJson {
final int id;
final int startHour;
final int startMinute;
final int endHour;
final int endMinute;
SlotJson({
required this.id,
required this.startHour,
required this.startMinute,
required this.endHour,
required this.endMinute,
});
factory SlotJson.fromJson(Map<String, dynamic> json) => SlotJson(
id: json['id'] as int,
startHour: json['startHour'] as int,
startMinute: json['startMinute'] as int,
endHour: json['endHour'] as int,
endMinute: json['endMinute'] as int,
);
}
// "leichte" Form eines Termins (siehe getMapForAppointment auf der NestJS-Seite)
class AppointmentJson {
final int id;
final String day; // Format "yyyy-MM-dd"
final Client? client;
final SlotJson? slot;
AppointmentJson({required this.id, required this.day, required this.client, required this.slot});
factory AppointmentJson.fromJson(Map<String, dynamic> json) => AppointmentJson(
id: json['id'] as int,
day: json['day'] as String,
client: json['client'] == null ? null : Client.fromJson(json['client'] as Map<String, dynamic>),
slot: json['slot'] == null ? null : SlotJson.fromJson(json['slot'] as Map<String, dynamic>),
);
}
// ein Slot im Terminkalender eines Arztes, frei (appointment == null) oder gebucht
class DoctorDaySlot {
final SlotJson slot;
final AppointmentJson? appointment;
DoctorDaySlot({required this.slot, required this.appointment});
factory DoctorDaySlot.fromJson(Map<String, dynamic> json) => DoctorDaySlot(
slot: SlotJson.fromJson(json['slot'] as Map<String, dynamic>),
appointment: json['appointment'] == null ? null : AppointmentJson.fromJson(json['appointment'] as Map<String, dynamic>),
);
}
// der vollständige Terminkalender eines Arztes für einen bestimmten Tag (siehe GET /getDoctorScheduleOfDay/:doctorId/:day)
class DoctorDaySchedule {
final Doctor doctor;
final String day;
final List<DoctorDaySlot> slots;
DoctorDaySchedule({required this.doctor, required this.day, required this.slots});
factory DoctorDaySchedule.fromJson(Map<String, dynamic> json) => DoctorDaySchedule(
doctor: Doctor.fromJson(json['doctor'] as Map<String, dynamic>),
day: json['day'] as String,
slots: (json['slots'] as List<dynamic>)
.map((e) => DoctorDaySlot.fromJson(e as Map<String, dynamic>))
.toList(),
);
}
// -------------------------------------------------------------------------
// Authentifizierung (siehe Server: src/auth/, insbesondere login-result.model.ts)
// -------------------------------------------------------------------------
// die einzigen beiden von der Anwendung behandelten Rollen - exakte Kopie des
// Typs [Role] des Servers (src/entities/user.entity.ts). Wo TypeScript sich
// mit einer Union von Strings begnügt ('ADMIN' | 'USER'), hat Dart einen
// echten Aufzählungsbegriff (enum): sicherer (es ist unmöglich, versehentlich
// eine andere Role als diese beiden Werte zu erzeugen), auf Kosten einer kleinen expliziten Hin- und Rückumwandlung
// mit dem JSON-String ("ADMIN"/"USER") über
// fromString(...)/asString() unten - ein TypeScript-"type Role =
// 'ADMIN' | 'USER'" braucht gar keine Umwandlung, ein JSON-String IST
// für ihn bereits ein gültiger Wert des Typs.
enum Role {
admin,
user;
static Role fromString(String value) {
switch (value) {
case 'ADMIN':
return Role.admin;
case 'USER':
return Role.user;
default:
throw ArgumentError('Unknown role: $value');
}
}
String asString() => this == Role.admin ? 'ADMIN' : 'USER';
}
// Form der von POST /login zurückgegebenen Daten (in der üblichen ServerResponse<T>-Hülle)
class LoginResult {
final String accessToken;
final String login;
final String name;
final Role role;
LoginResult({required this.accessToken, required this.login, required this.name, required this.role});
factory LoginResult.fromJson(Map<String, dynamic> json) => LoginResult(
accessToken: json['accessToken'] as String,
login: json['login'] as String,
name: json['name'] as String,
role: Role.fromString(json['role'] as String),
);
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 11–22: Der Kopfkommentar erläutert den wesentlichen strukturellen Unterschied in dieser Datei – ein [interface] [TypeScript] wird nur zur KOMPILIERZEIT geprüft; [Dart] BEHÄLT seine Typen zur Laufzeit, daher ein expliziter Konstruktor [fromJson(...)] in jeder Klasse (in [appointment.models.ts] nicht vorhanden).
- Zeilen 37–53: [class ServerResponse<T>] und ihre Factory [fromJson(json, parseData)] – erhält eine FUNKTION ([parseData]), anstatt sich wie auf der [TypeScript]-Seite auf ein einfaches [as ServerResponse<T>] zu verlassen (siehe [appointment.service.ts]): [Dart] kennt [T] zur Laufzeit nicht (Type Erasure), kann also nicht selbst [T.fromJson(...)] schreiben.
- Zeilen 71–73: Der Kommentar weist darauf hin, dass [Client] einen PATIENTEN der Arztpraxis bezeichnet (Vokabular der Fachdomäne) – nicht zu verwechseln mit „HTTP-Client“ und auch nicht mit diesem [Flutter]-Client selbst, eine Mehrdeutigkeit, die bereits in den drei vorherigen Web-Varianten erwähnt wurde.
- Zeilen 176–192: [enum Role { admin, user; ... }] – ersetzt die [TypeScript]-String-Union [type Role = 'ADMIN' | 'USER'] durch eine ECHTE [Dart]-Enumeration mit explizitem Hin- und Rückweg zum JSON-String ([fromString]/[asString]) – das ist sicherer (es ist unmöglich, eine ungültige [Role] zu erzeugen), um den Preis einer Konvertierung, die eine String-Union nicht benötigt.
5.6. Die Schicht core/services

5.6.1. lib/core/services/settings_service.dart
Portierung von [core/composables/settings.composable.ts]: hält die URL des [NestJS]-Servers im Speicher.
| // =========================================================================
// core/services/settings_service.dart
// -------------------------------------------------------------------------
// Port von core/composables/settings.composable.ts (Vue.js-Client dieses
// Kurses): ein winziger "Store", der die URL des NestJS-Servers
// im Speicher hält.
//
// Vue.js stellt diesen gemeinsamen Zustand über das Paar [provide]/[inject] bereit: ein
// [reactive(...)]-Objekt, das nur einmal erzeugt und dann
// von jeder untergeordneten Komponente direkt gelesen/geändert wird. Flutter hat weder [reactive] noch
// [provide]/[inject]: Das Standardäquivalent des Ökosystems (und das
// in diesem Kurs verwendete) ist ein ChangeNotifier - eine gewöhnliche Dart-Klasse,
// die zusätzlich zu ihren Feldern ihre Listener
// bei jeder Änderung, die eine neue Anzeige bewirken muss, BENACHRICHTIGEN kann, durch
// den expliziten Aufruf von notifyListeners().
//
// Der wesentliche Unterschied zu Vue.js: [reactive(...)] hüllt das Objekt
// in einen JavaScript-Proxy, der jeden Schreibzugriff auf eine Eigenschaft AUTOMATISCH erkennt
// (store.apiBaseUrl = ... zeichnet die Komponenten, die
// apiBaseUrl lesen, von selbst neu). Ein Dart-ChangeNotifier hingegen erkennt von
// sich aus NICHTS: Der Entwickler muss nach jeder
// Änderung notifyListeners() aufrufen - etwas mehr Disziplin von Hand, im Gegenzug ein
// viel einfacher zu verstehender
// und zu debuggender Mechanismus (kein Proxy, keine "Magie").
//
// Es ist das Paket [provider] (siehe pubspec.yaml und lib/main.dart), das dann
// um diesen ChangeNotifier herum die Rolle von app.provide(...) auf der
// Vue.js-Seite spielt: Es stellt diese einzelne Instanz dem gesamten
// Widget-Teilbaum bereit, über context.watch<SettingsService>() (zum "Lesen und
// erneuten Abonnieren von Änderungen", siehe lib/app.dart) oder context.read<...>()
// (zum "einmaligen Lesen ohne erneutes Abonnieren").
// =========================================================================
import 'package:flutter/foundation.dart';
class SettingsService extends ChangeNotifier {
String _apiBaseUrl = 'http://localhost:8080';
String get apiBaseUrl => _apiBaseUrl;
// Äquivalent von "setApiBaseUrl(url: string)" auf der Vue.js-Seite - anders als
// store.apiBaseUrl = url (eine bloße Zuweisung, die dank des
// reaktiven Proxys genügt) müssen hier die Listener nach der Änderung des privaten Felds
// explizit benachrichtigt werden.
void setApiBaseUrl(String url) {
if (url == _apiBaseUrl) {
return; // vermeidet ein unnötiges Neuzeichnen, wenn sich der Wert nicht wirklich geändert hat
}
_apiBaseUrl = url;
notifyListeners();
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 36–39: [class SettingsService extends ChangeNotifier] mit einem PRIVATEN Feld ([_apiBaseUrl]) und einem öffentlichen Accessor ([get apiBaseUrl]) – ein [ChangeNotifier] ist eine GEWÖHNLICHE [Dart]-Klasse ohne einen Proxy wie [reactive(...)] auf der Seite von [Vue.js]: Nichts erkennt automatisch das Lesen oder Schreiben einer Eigenschaft.
- Zeilen 45–51: [setApiBaseUrl(url)] ruft ausdrücklich [notifyListeners()] NACH der Aktualisierung des Felds auf – der manuelle Schritt, den [store.apiBaseUrl = url] auf der Seite von [Vue.js] nicht ausführen musste, da der reaktive Proxy dies selbst erledigt.
5.6.2. lib/core/services/auth_service.dart
Portierung von [core/composables/auth.composable.ts]: verwaltet die Anmeldung (POST [/login]), hält das [JWT]-Token vor und sorgt dafür, dass es einen Neustart überdauert, mithilfe von [shared_preferences].
| // =========================================================================
// core/services/auth_service.dart
// -------------------------------------------------------------------------
// Port von core/composables/auth.composable.ts (Vue.js-Client dieses
// Kurses): behandelt die Anmeldung des Benutzers, ruft POST /login auf, behält
// das empfangene JWT-Token (und die Identität/Rolle, die dazugehören) und lässt es
// dank shared_preferences einen Neustart der Anwendung überleben - das
// plattformübergreifende Äquivalent von localStorage (siehe unten).
//
// Wie auf der Vue.js-Seite ist dies, neben
// core/services/appointment_service.dart, die einzige weitere Stelle der Anwendung, die per HTTP mit dem Server spricht - eine
// bewusste Ausnahme von der Regel "eine einzige Stelle, die HTTP spricht", die
// auf der Client-Seite die bereits auf der Serverseite vorgenommene Trennung zwischen
// RdvMedecinsController (Geschäftslogik) und AuthController (Authentifizierung) widerspiegelt.
//
// WICHTIGER UNTERSCHIED zu Vue.js: readStoredSession() (auf der Vue.js-Seite)
// ist SYNCHRON - localStorage.getItem(...) liefert seinen Wert
// sofort, noch vor dem ersten Rendern der Anwendung. shared_
// preferences hingegen ist IMMER asynchron (SharedPreferences.getInstance()
// liefert ein Future), auch auf den Plattformen, auf denen der zugrunde liegende Speicher
// tatsächlich eine lokale Datei ist, die fast sofort gelesen wird: Die Dart-API
// unterscheidet diese Fälle nicht, aus Gründen der Einheitlichkeit über ALLE Plattformen (im
// Web stützt sich derselbe Aufruf auf window.localStorage, aber die Dart-API
// bleibt asynchron, um mit den anderen Zielplattformen identisch zu bleiben). Konkrete
// Folge: Man kann die bereits gespeicherte Sitzung nicht mehr wie auf der Vue.js-Seite lesen,
// BEVOR der Widget-Baum eingehängt wird - es braucht ein [init()],
// das explizit asynchron ist und aus
// lib/main.dart vor runApp(...) aufgerufen (und mit await ABGEWARTET) wird, damit der Anmeldebildschirm nicht
// für den Bruchteil einer Sekunde "flackert", bevor die Sitzung wiederhergestellt ist.
// =========================================================================
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'package:shared_preferences/shared_preferences.dart';
import '../models/appointment_models.dart';
import 'settings_service.dart';
const String _storageKey = 'rdvmedecins.session';
class AuthService extends ChangeNotifier {
// im Konstruktor entgegengenommen, statt per Flutter-Injection bezogen: In diesem
// Stadium (siehe lib/main.dart) existiert noch kein Widget, also wäre nichts
// wie context.read<SettingsService>() möglich - genau
// derselbe Grund wie der in createAuthStore(settings) auf der
// Vue.js-Seite (src/main.ts) dokumentierte, das settingsStore ebenfalls als Funktionsparameter
// erhält, statt über inject().
final SettingsService settings;
AuthService(this.settings);
bool isLoggedIn = false;
String? login;
String? name;
Role? role;
String? accessToken;
bool get isAdmin => role == Role.admin;
// -----------------------------------------------------------------------
// nur EINMAL in lib/main.dart aufzurufen, VOR runApp(...): liest
// eine eventuell bei einem früheren Start der
// Anwendung gespeicherte Sitzung erneut ein - Äquivalent von readStoredSession() auf der Vue.js-Seite, aber
// explizit asynchron (siehe den Kopf dieser Datei) statt
// im Konstruktor des Stores selbst aufgerufen.
// -----------------------------------------------------------------------
Future<void> init() async {
try {
final prefs = await SharedPreferences.getInstance();
final raw = prefs.getString(_storageKey);
if (raw == null) {
return; // keine gespeicherte Sitzung: Wir bleiben "nicht angemeldet", Standardwerte oben
}
final session = jsonDecode(raw) as Map<String, dynamic>;
_applyLocalSession(
accessToken: session['accessToken'] as String,
login: session['login'] as String,
name: session['name'] as String,
role: Role.fromString(session['role'] as String),
);
} catch (_) {
// shared_preferences kann nicht verfügbar sein oder einen beschädigten
// Wert enthalten - in diesem Fall betrachten wir, wie auf der Vue.js-Seite (try/catch von
// readStoredSession()), einfach, dass es keine
// Sitzung gibt, statt den Start der Anwendung abstürzen zu lassen.
}
// kein notifyListeners() hier: init() wird vor
// runApp(...) in lib/main.dart abgewartet, daher lauscht beim Ausführen dieser Methode noch kein Widget
// auf diesen ChangeNotifier - eine Benachrichtigung
// wäre nutzlos (und würde in manchen Debug-Konfigurationen sogar eine Exception auslösen, da ein Flutter-ChangeNotifier
// notifyListeners() verbietet, solange es noch nicht mindestens einen
// Listener gibt).
}
// -----------------------------------------------------------------------
// Äquivalent von: POST /login JSON-Body { login, password }
// -----------------------------------------------------------------------
Future<LoginResult> logIn(String login, String password) async {
final httpResponse = await http.post(
Uri.parse('${settings.apiBaseUrl}/login'),
headers: {'Content-Type': 'application/json'},
body: jsonEncode({'login': login, 'password': password}),
);
final envelope = ServerResponse<LoginResult>.fromJson(
jsonDecode(httpResponse.body) as Map<String, dynamic>,
(data) => LoginResult.fromJson(data as Map<String, dynamic>),
);
if (envelope.status != 0 || envelope.data == null) {
throw Exception('Login failed');
}
final result = envelope.data!;
await _applySessionAndPersist(result);
return result;
}
// -----------------------------------------------------------------------
// Abmelden: rein lokal (kein Serveraufruf - ein JWT-Token wird in diesem Port serverseitig nicht
// "widerrufen", es läuft nach JWT_EXPIRES_IN von selbst ab, siehe .env des Servers).
// Aufgerufen sowohl durch einen Klick auf
// "Log out" (siehe lib/app.dart) als auch durch core/http/auth_http_client.dart,
// wenn eine geschützte Anfrage ein 401 erhält.
// -----------------------------------------------------------------------
Future<void> logOut() async {
login = null;
name = null;
role = null;
accessToken = null;
isLoggedIn = false;
notifyListeners();
try {
final prefs = await SharedPreferences.getInstance();
await prefs.remove(_storageKey);
} catch (_) {
// auch hier darf ein Fehler beim Leeren des Speichers das
// Abmelden auf der Anwendungsseite, das oben bereits wirksam ist, nicht verhindern.
}
}
// aktualisiert die reaktiven Felder, OHNE den Speicher anzufassen - verwendet von
// init() (das den Speicher gerade GELESEN hat, ein erneutes Schreiben ist unnötig).
void _applyLocalSession({
required String accessToken,
required String login,
required String name,
required Role role,
}) {
this.accessToken = accessToken;
this.login = login;
this.name = name;
this.role = role;
isLoggedIn = true;
}
// aktualisiert die reaktiven Felder UND speichert die Sitzung dauerhaft - verwendet von
// logIn() oben. Fasst zusammen, was applySession(...)
// auf der Vue.js-Seite in einem einzigen Block tat (reaktiver Zustand + localStorage gemeinsam
// geschrieben); hier sind die beiden Operationen getrennt, weil das Schreiben
// asynchron ist (await prefs.setString(...)), während die Aktualisierung
// der Felder SOFORT und synchron erfolgen muss
// (notifyListeners() muss der Zuweisung der Felder folgen, ohne auf
// Festplatten-I/O zu warten) - eine Umkehrung der Reihenfolge würde die Aktualisierung
// der Oberfläche unnötig verzögern.
Future<void> _applySessionAndPersist(LoginResult result) async {
_applyLocalSession(
accessToken: result.accessToken,
login: result.login,
name: result.name,
role: result.role,
);
notifyListeners();
try {
final prefs = await SharedPreferences.getInstance();
await prefs.setString(
_storageKey,
jsonEncode({
'accessToken': result.accessToken,
'login': result.login,
'name': result.name,
'role': result.role.asString(),
}),
);
} catch (_) {
// Die Sitzung bleibt für diesen Lauf der
// Anwendung IM SPEICHER gültig, auch wenn das dauerhafte Speichern fehlschlägt (Kontingent überschritten,
// schreibgeschützter Speicher...) - nur ein späterer Neustart der
// Anwendung würde darunter leiden (der Benutzer müsste sich erneut anmelden).
}
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 16–29: Der Kopfkommentar erläutert den bedeutsamsten Unterschied in dieser Datei – [readStoredSession()] ist auf der Seite von [Vue.js] SYNCHRON; [shared_preferences] ist unabhängig von der Plattform IMMER asynchron, daher ein explizites [async] [init()], auf das [lib/main.dart] VOR [runApp(...)] wartet.
- Zeilen 69–95: [Future<void> init() async { ... }] – liest eine eventuell zwischengespeicherte Sitzung, geschützt durch ein [try/catch] – dieselbe Vorsichtsmaßnahme wie beim [try/catch] von [readStoredSession()] auf der Seite von [Vue.js] (Speicher nicht verfügbar oder Wert beschädigt).
- Zeilen 100–116: [logIn(login, password)] – ruft POST [/login] mit dem Paket [http] auf (das Äquivalent zu [fetch]) und wirft im Fehlerfall eine Standardausnahme von [Dart] ([throw Exception(...)]), die später von einem [try/catch] [Dart] abgefangen wird, so wie das [throw new Error(...)] aus [auth.composable.ts] von einem [.catch(...)] [JavaScript] abgefangen wurde.
- Zeilen 165–190: [_applySessionAndPersist(...)] – aktualisiert die Felder UND ruft [notifyListeners()] auf, BEVOR geschrieben wird, und zwar nach [shared_preferences]: Die Reihenfolge ist beabsichtigt – die Oberfläche muss SOFORT aktualisiert werden, ohne auf einen asynchronen Schreibvorgang auf die Festplatte zu warten, während [applySession(...)] auf der Seite von [Vue.js] beide Operationen in einer einzigen synchronen Anweisung ausführte.
5.6.3. lib/core/services/appointment_service.dart
Portierung von [core/services/appointment.service.ts]: die fünf fachlichen Aufrufe an den Server, aufgebaut auf [core/http/auth_http_client.dart] (weiter unten) und nicht direkt auf dem Paket [http].
| // =========================================================================
// core/services/appointment_service.dart
// -------------------------------------------------------------------------
// Port von core/services/appointment.service.ts (Vue.js-Client dieses Kurses): die
// Schicht [Services] des Flutter-Clients - die EINZIGE Stelle der Anwendung
// (zusammen mit core/services/auth_service.dart für die Anmeldung selbst), die
// mit dem NestJS-Server per HTTP spricht.
//
// Vue.js stellt diesen Service als COMPOSABLE (useAppointmentService()) bereit, das selbst
// auf zwei weiteren Composables (useAuthFetch(), useSettings()) aufbaut.
// Da Flutter/Dart weder Composables noch eine in die Sprache eingebaute
// Dependency Injection kennt, wird diese Datei wieder zu einer gewöhnlichen KLASSE, die nur
// einmal in lib/main.dart gebaut wird, mit ihren beiden an den
// Konstruktor übergebenen Abhängigkeiten - genau dasselbe Prinzip wie bei core/http/auth_http_client.dart,
// und der direkteste Weg, "eine Menge von Funktionen, die
// von etwas anderem abhängen" zu portieren, wenn die Zielsprache keine Composables bietet.
// =========================================================================
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../http/auth_http_client.dart';
import '../models/appointment_models.dart';
import 'settings_service.dart';
class AppointmentService {
final AuthHttpClient authHttp;
final SettingsService settings;
AppointmentService(this.authHttp, this.settings);
// -----------------------------------------------------------------------
// gemeinsame private Funktion: Alle Serverantworten haben die Form
// { status, data } (siehe core/models/appointment_models.dart). Die Regel
// "wenn status != 0, liegt ein Fehler vor" wird HIER zentralisiert, nur einmal, statt
// in jeder der folgenden Methoden wiederholt zu werden - genau die
// Rolle von extract<T>(...) auf der Vue.js-Seite.
//
// [parseData] ist dieselbe Art von Parameter wie der bereits in
// ServerResponse.fromJson(...) (siehe appointment_models.dart) angetroffene: die Funktion, die aus dem rohen JSON des Feldes [data] ein T
// wiederherstellen kann, da Dart
// dies nicht von selbst kann (kein generisches "T.fromJson(...)").
// -----------------------------------------------------------------------
T _extract<T>(http.Response httpResponse, T Function(dynamic rawData) parseData) {
final envelope = ServerResponse<T>.fromJson(
jsonDecode(httpResponse.body) as Map<String, dynamic>,
parseData,
);
if (envelope.status != 0) {
// Der "fachliche" Fehler des Servers wird in eine klassische
// Dart-Exception umgewandelt, die die aufrufenden Widgets mit einem
// einfachen try/catch abfangen können (siehe lib/app.dart) - genau wie das
// "throw new Error(...)" in appointment.service.ts, das vom
// .catch(...) in src/app/App.vue abgefangen wird.
throw Exception('The server responded with error status ${envelope.status}');
}
return envelope.data as T;
}
// -----------------------------------------------------------------------
// Äquivalent von: GET /getAllDoctors
// -----------------------------------------------------------------------
Future<List<Doctor>> getAllDoctors() async {
final httpResponse = await authHttp.get(Uri.parse('${settings.apiBaseUrl}/getAllDoctors'));
return _extract<List<Doctor>>(
httpResponse,
(data) => (data as List<dynamic>).map((e) => Doctor.fromJson(e as Map<String, dynamic>)).toList(),
);
}
// -----------------------------------------------------------------------
// Äquivalent von: GET /getAllClients
// -----------------------------------------------------------------------
Future<List<Client>> getAllClients() async {
final httpResponse = await authHttp.get(Uri.parse('${settings.apiBaseUrl}/getAllClients'));
return _extract<List<Client>>(
httpResponse,
(data) => (data as List<dynamic>).map((e) => Client.fromJson(e as Map<String, dynamic>)).toList(),
);
}
// -----------------------------------------------------------------------
// Äquivalent von: GET /getDoctorScheduleOfDay/{doctorId}/{day}
// -----------------------------------------------------------------------
Future<DoctorDaySchedule> getDoctorScheduleOfDay(int doctorId, String day) async {
final httpResponse = await authHttp.get(
Uri.parse('${settings.apiBaseUrl}/getDoctorScheduleOfDay/$doctorId/$day'),
);
return _extract<DoctorDaySchedule>(
httpResponse,
(data) => DoctorDaySchedule.fromJson(data as Map<String, dynamic>),
);
}
// -----------------------------------------------------------------------
// Äquivalent von: POST /addAppointment JSON-Body { day, clientId, slotId }
// -----------------------------------------------------------------------
Future<AppointmentJson> addAppointment(String day, int clientId, int slotId) async {
final httpResponse = await authHttp.post(
Uri.parse('${settings.apiBaseUrl}/addAppointment'),
body: jsonEncode({'day': day, 'clientId': clientId, 'slotId': slotId}),
);
return _extract<AppointmentJson>(httpResponse, (data) => AppointmentJson.fromJson(data as Map<String, dynamic>));
}
// -----------------------------------------------------------------------
// Äquivalent von: POST /deleteAppointment JSON-Body { appointmentId }
// -----------------------------------------------------------------------
Future<void> deleteAppointment(int appointmentId) async {
final httpResponse = await authHttp.post(
Uri.parse('${settings.apiBaseUrl}/deleteAppointment'),
body: jsonEncode({'appointmentId': appointmentId}),
);
_extract<Object?>(httpResponse, (data) => data);
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 27–31: [class AppointmentService { final AuthHttpClient authHttp; final SettingsService settings; AppointmentService(this.authHttp, this.settings); }] – kehrt zu einer GEWÖHNLICHEN KLASSE zurück, die einmalig in [lib/main.dart] erzeugt wird und deren Abhängigkeiten dem Konstruktor übergeben werden, während [Vue.js] ein COMPOSABLE verwendete, [useAppointmentService()], das seinerseits aus zwei weiteren Composables aufgebaut war.
- Zeilen 45–59: [T _extract<T>(httpResponse, parseData)] – bündelt an einer einzigen Stelle die Regel „wenn [status != 0], liegt ein Fehler vor“, genau die Rolle von [extract<T>(...)] auf der Seite von [Vue.js] – der Parameter [parseData] ist dieselbe Art von Funktion, der wir bereits in [ServerResponse.fromJson(...)] begegnet sind.
- Zeilen 99–105: [addAppointment(day, clientId, slotId)] – [jsonEncode({...})] erzeugt den JSON-Body der POST-Anfrage, das Äquivalent in [Dart] zu [JSON.stringify({...})] auf der Seite von [Vue.js].
- Zeilen 110–116: [Future<void> deleteAppointment(int appointmentId) async { ... }] – ruft [_extract<Object?>(...)] auf, ohne dessen Ergebnis zu verwenden: Der Server liefert [ServerResponse.ok(null)] für diese Route zurück, es gibt also nichts Spezifischeres anzugeben – dieselbe Entscheidung wie bei [extract<null>(httpResponse)] auf der Seite von [Vue.js].
5.7. Die Schicht core/http

5.7.1. lib/core/http/auth_http_client.dart
Portierung von [core/interceptors/auth.interceptor.ts]: fügt jeder geschützten Anfrage das [JWT]-Token hinzu und meldet den Benutzer bei einer 401-Antwort ab.
| // =========================================================================
// core/http/auth_http_client.dart
// -------------------------------------------------------------------------
// Port von core/interceptors/auth.interceptor.ts (Vue.js-Client dieses
// Kurses). Diese Datei tut zwei Dinge, genau wie ihr
// Vue.js-Gegenstück (selbst ein Port der Angular- und React-Clients):
// 1. fügt jeder Anfrage den Header "Authorization: Bearer <token>" hinzu, wenn
// der Benutzer angemeldet ist (siehe AuthService.accessToken);
// 2. wenn der Server mit 401 antwortet (Token fehlt, ungültig oder abgelaufen),
// meldet er den Benutzer clientseitig sauber ab.
//
// [fetch] (auf der Vue.js- und React-Seite verwendet) und Angulars [HttpClient] haben
// in Dart KEIN DIREKTES Äquivalent: Das Paket [http] (siehe pubspec.yaml)
// stellt freie Funktionen (http.get(...), http.post(...)) bereit, statt
// eines Objekts, das global abgefangen werden könnte. Der Port bleibt dennoch
// dem GEIST von useAuthFetch() treu: Statt einer Composable-Funktion, die
// ein "erweitertes fetch" liefert, wird hier eine ECHTE KLASSE geschrieben, [AuthHttpClient],
// deren Methoden get(...)/post(...) genau dieselbe Rolle spielen -
// jeder Code, der mit dem Server sprechen will (hier nur
// core/services/appointment_service.dart), ruft DIESE Methoden auf statt direkt das
// Paket http.
//
// Eine Klasse statt einer Composable-Funktion zu schreiben, ist in Dart/Flutter eine natürliche
// Wahl: Anders als ein Vue.js-<script setup> (das
// nur einmal pro Komponenteninstanz läuft, siehe den Kommentar zu
// auth.interceptor.ts), hat ein ChangeNotifier oder eine Dart-Service-Klasse
// keinen "bei jedem Rendern ausgeführten Rumpf", vor dem man sich hüten müsste -
// also braucht es auch hier kein Äquivalent von useCallback(),
// aber aus einem anderen Grund: Es gibt schlicht keine
// Funktion, die "bei jedem Rendern neu erzeugt" wird, da die Klasse
// nur einmal von lib/main.dart gebaut wird (siehe unten).
// =========================================================================
import 'dart:async' show unawaited;
import 'package:http/http.dart' as http;
import '../services/auth_service.dart';
class AuthHttpClient {
final AuthService auth;
final http.Client _client = http.Client();
AuthHttpClient(this.auth);
Future<http.Response> get(Uri url) => _send(() => _client.get(url, headers: _headers()));
Future<http.Response> post(Uri url, {required Object body}) => _send(
() => _client.post(
url,
headers: {..._headers(), 'Content-Type': 'application/json'},
body: body,
),
);
// baut die Header, die jeder geschützten Anfrage gemeinsam sind - das Äquivalent
// von "new Headers(options.headers); if (auth.accessToken) {...}" auf der
// Vue.js-Seite, aber als einfache Map<String, String> (der Typ,
// den das Paket http erwartet, hier einfacher als eine Klasse Headers).
Map<String, String> _headers() {
final accessToken = auth.accessToken;
return accessToken == null ? {} : {'Authorization': 'Bearer $accessToken'};
}
// faktorisiert heraus, was get(...) und post(...) gemeinsam haben: den HTTP-Aufruf
// ausführen und dann, wenn die Antwort 401 lautet, den Benutzer abmelden - die
// als Parameter erhaltene Funktion [call] spielt die Rolle der "...options",
// die auf der Vue.js-Seite von fetch(path, { ...options, headers }) übergeben werden:
// An dieser Stelle wissen wir noch nicht, ob es ein GET
// oder ein POST ist, nur dass er ausgeführt und seine Antwort geprüft werden muss.
Future<http.Response> _send(Future<http.Response> Function() call) async {
final response = await call();
// Ein 401 während einer Sitzung bedeutet, dass das Token nicht mehr gültig ist
// (abgelaufen oder Server neu gestartet): Der Client wird sauber abgemeldet,
// statt die Anwendung in einem inkonsistenten Zustand zu belassen (dem Anschein nach angemeldet,
// aber ohne dass noch eine Anfrage gelingt). Es gibt
// kein "await" auf logOut(): Die HTTP-Antwort (auch eine fehlerhafte)
// muss an den Aufrufer zurückgegeben werden, ohne auf das Ende des Leerens
// des lokalen Speichers zu warten, das seinerseits im Hintergrund abgeschlossen wird.
if (response.statusCode == 401) {
unawaited(auth.logOut());
}
return response;
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 12–31: Der Kopfkommentar erläutert die Entscheidung für eine KLASSE ([AuthHttpClient]) anstelle eines Composables – [fetch] ([Vue.js]/[React]) und [HttpClient] ([Angular]) haben in [Dart] kein direktes Äquivalent; das Paket [http] stellt eigenständige Funktionen bereit statt eines einzelnen Objekts, das global abgefangen werden könnte.
- Zeilen 46–54: [get(...)]/[post(...)] – die einzigen beiden Methoden, die [appointment_service.dart] aufruft; das Paket [http] wird nie direkt aufgerufen.
- Zeilen 60–63: [_headers()] – erstellt [{'Authorization': 'Bearer $accessToken'}] , wenn der Benutzer angemeldet ist; das entspricht [new Headers(options.headers); if (auth.accessToken) {...}] auf der Seite von [Vue.js], jedoch in Form einer einfachen [Map<String, String>].
- Zeilen 71–84: [_send(call)] – fasst zusammen, was [get(...)] und [post(...)] gemeinsam haben; [unawaited(auth.logOut())] dokumentiert AUSDRÜCKLICH, dass wir uns entscheiden, nicht auf das [Future] zu warten – die HTTP-Antwort (auch wenn sie einen Fehler enthält) muss an den Aufrufer zurückgegeben werden, ohne abzuwarten, bis das Leeren des lokalen Speichers abgeschlossen ist.
5.8. Die Schicht core/i18n

5.8.1. lib/core/i18n/translations_service.dart
ZUSAMMENGEFÜHRTE Portierung von [src/i18n.ts] UND von [core/composables/language.composable.ts]: das Umschalten der Oberfläche zwischen Französisch und Englisch, ohne Bibliothek eines Drittanbieters neu implementiert (den Grund für diese Entscheidung nennt der Kopfkommentar in der Datei).
| // =========================================================================
// core/i18n/translations_service.dart
// -------------------------------------------------------------------------
// ZUSAMMENGEFÜHRTER Port von src/i18n.ts (Konfiguration von vue-i18n) UND von
// core/composables/language.composable.ts (Vue.js-Client dieses Kurses).
// Vue.js trennt beide, weil vue-i18n, eine Drittanbieter-Bibliothek mit bereits
// vielen Funktionen (Pluralisierung, Datums-/Zahlenformate...),
// die gesamte eigentliche Übersetzungsarbeit leistet; language.composable.ts
// ergänzt lediglich das Speichern der Sprachwahl in
// localStorage. Flutter hat kein direktes Äquivalent zu vue-i18n/react-
// i18next/@ngx-translate/core, das standardmäßig installiert ist: Statt
// eine zusätzliche Abhängigkeit aufzunehmen, implementiert diese Datei in wenigen
// Zeilen genau die in diesem Kurs verwendete Teilmenge - ein
// Wörterbuch mit Punkt-Schlüsseln ("LOGIN.TITLE") und eine Funktion t(key).
//
// WICHTIGER PLATTFORMUNTERSCHIED (siehe auch Kapitel "Porting
// the application to mobile, desktop and web"): src/i18n.ts lädt
// jedes Wörterbuch mit einem fetch("/i18n/{language}.json") - eine relative
// URL, die einen WEBSERVER voraussetzt, der die Dateien des Clients ausliefert (Vite in der Entwicklung, ein
// statischer Server nach dem Build). Eine mobile
// oder Desktop-Flutter-Anwendung hat KEINEN WEBSERVER, der sie ausliefert
// : Der Code UND seine statischen Ressourcen (hier die JSON-Dateien) sind
// gemeinsam in ein einziges, auf dem Gerät installiertes Paket EINGEBETTET (.apk,
// .app, .exe...). Deshalb verwendet diese Datei rootBundle.loadString(...)
// - die Flutter-API, die eine im Abschnitt [assets] von
// pubspec.yaml deklarierte Datei direkt aus diesem Paket liest - statt eines Netzwerkaufrufs.
// Auf dem Web-Ziel stützt sich rootBundle im Hintergrund auf eine echte HTTP-Anfrage
// an die neben der Anwendung veröffentlichten Dateien, aber dieses Detail
// bleibt hier unsichtbar: Derselbe Dart-Code funktioniert ohne jede Plattformbedingung
// in den 3 Umgebungen - genau das zentrale Argument dieses
// Kapitels.
// =========================================================================
import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:flutter/services.dart' show rootBundle, ServicesBinding;
import 'package:shared_preferences/shared_preferences.dart';
const String _storageKey = 'rdvmedecins.language';
final String _defaultLanguage = ServicesBinding.instance.platformDispatcher.locale.languageCode == 'fr' ? 'fr' : 'en';
class TranslationsService extends ChangeNotifier {
String currentLanguage = _defaultLanguage;
// bereits geladene Wörterbücher (vermeidet das erneute Lesen einer schon gesehenen Asset-Datei
// während der Sitzung) - dieselbe Optimierung wie loadedDictionaries auf der
// Vue.js-Seite (src/i18n.ts), aber hier wird das dekodierte Wörterbuch selbst aufbewahrt
// statt eines einfachen Sets bereits gesehener Sprachen: Vue.js konnte sich mit einem Set begnügen,
// weil vue-i18n SELBST die geladenen Wörterbücher
// im Speicher hält (setLocaleMessage); da hier keine entsprechende
// Bibliothek existiert, muss diese Cache-Rolle direkt von dieser
// Datei übernommen werden.
final Map<String, Map<String, dynamic>> _dictionaries = {};
// -----------------------------------------------------------------------
// nur EINMAL in lib/main.dart aufzurufen, VOR runApp(...):
// stellt die bei einem früheren Start gespeicherte Sprache wieder her (falls
// vorhanden) und lädt ihr Wörterbuch - Äquivalent des letzten Blocks von
// createLanguageStore() auf der Vue.js-Seite (das Lesen von savedLanguage in
// localStorage), aber aus denselben Gründen, die bereits in core/services/auth_service.dart dokumentiert sind,
// explizit asynchron gemacht
// (shared_preferences ist IMMER asynchron, anders als
// localStorage).
// -----------------------------------------------------------------------
Future<void> init() async {
String startLanguage = _defaultLanguage;
try {
final prefs = await SharedPreferences.getInstance();
startLanguage = prefs.getString(_storageKey) ?? _defaultLanguage;
} catch (_) {
// keine lesbare Einstellung: in der Standardsprache starten (Englisch oder
// Französisch auf einem französischen Gerät), wie auf der Vue.js-Seite.
}
await _loadDictionary(startLanguage);
currentLanguage = startLanguage;
// kein notifyListeners() hier, aus demselben Grund wie in
// AuthService.init(): Diese Methode wird vor
// runApp(...) abgewartet, daher lauscht noch kein Widget auf diesen ChangeNotifier.
}
// -----------------------------------------------------------------------
// Äquivalent von: changeLanguage(language) auf der Vue.js-Seite (ausgelöst durch die
// FR/EN-Buttons von lib/app.dart, siehe weiter hinten in diesem Kapitel).
// -----------------------------------------------------------------------
Future<void> changeLanguage(String language) async {
if (language == currentLanguage) {
return;
}
await _loadDictionary(language);
currentLanguage = language;
notifyListeners(); // hier hingegen läuft die Anwendung bereits: Wir benachrichtigen
try {
final prefs = await SharedPreferences.getInstance();
await prefs.setString(_storageKey, language);
} catch (_) {
// Der Sprachwechsel bleibt für diesen Lauf wirksam, auch wenn das
// Speichern fehlschlägt - nur ein späterer Neustart würde darunter leiden.
}
}
// -----------------------------------------------------------------------
// Äquivalent von: loadDictionary(language) auf der Vue.js-Seite - dasselbe
// Caching-Prinzip (loadedDictionaries), aber mit Lesen eines eingebetteten
// Assets statt eines Netzwerk-fetch() (siehe den Kopf dieser Datei).
// -----------------------------------------------------------------------
Future<void> _loadDictionary(String language) async {
if (_dictionaries.containsKey(language)) {
return; // bei einem früheren Sprachwechsel bereits geladen
}
final content = await rootBundle.loadString('assets/i18n/$language.json');
_dictionaries[language] = jsonDecode(content) as Map<String, dynamic>;
}
// -----------------------------------------------------------------------
// die Übersetzungsfunktion selbst - von den Widgets als t('LOGIN.TITLE') aufgerufen
// (siehe lib/features/...), genau wie t('LOGIN.TITLE')
// auf der Vue.js-Seite (useI18n().t). Der Schlüssel ist "gepunktet" (ein Punkt trennt
// jede Ebene): Wir steigen also Segment für Segment in das verschachtelte JSON-Wörterbuch
// hinab, statt das Wörterbuch ein für alle Mal
// zu verflachen, wie vue-i18n es intern tut - eine Wahl, die für die Größe dieser beiden Wörterbücher
// völlig ausreicht.
// -----------------------------------------------------------------------
String t(String key) {
final dictionary = _dictionaries[currentLanguage];
if (dictionary == null) {
return key; // Wörterbuch noch nicht geladen: Als letzter Ausweg wird der Schlüssel selbst angezeigt
}
dynamic currentValue = dictionary;
for (final segment in key.split('.')) {
if (currentValue is Map<String, dynamic> && currentValue.containsKey(segment)) {
currentValue = currentValue[segment];
} else {
return key; // Schlüssel nicht gefunden: derselbe Fallback wie oben
}
}
return currentValue is String ? currentValue : key;
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 16–31: Der Kopfkommentar erläutert den wichtigsten PLATTFORMUNTERSCHIED dieses gesamten Clients – [src/i18n.ts] lädt jedes Wörterbuch über [fetch("/i18n/{language}.json")], eine URL, die auf einem WEBSERVER beruht; eine mobile oder Desktop-Anwendung hat keinen, daher [rootBundle.loadString(...)] statt eines Netzwerkaufrufs – derselbe Code funktioniert unabhängig von der Plattform in allen drei Umgebungen (siehe Kapitel 5).
- Zeilen 66–80: [init()] – stellt die gespeicherte Sprache wieder her (oder die Standardsprache: Englisch bzw. Französisch auf einem französischen Gerät) und lädt ihr Wörterbuch; wie bei [AuthService.init()] gibt es hier kein [notifyListeners()] (zu diesem Zeitpunkt hört kein Widget auf diesen [ChangeNotifier]).
- Zeilen 107–113: [_loadDictionary(language)] – dasselbe Caching-Prinzip wie [loadedDictionaries] auf der Seite von [Vue.js], doch es speichert direkt das dekodierte Wörterbuch statt eines einfachen [Set] bereits gesehener Sprachen: [vue-i18n] hielt die Wörterbücher im Speicher ([setLocaleMessage]); hier muss diese Cache-Rolle direkt von dieser Datei übernommen werden.
- Zeilen 124–138: [String t(String key) { ... }] – durchläuft das verschachtelte JSON-Wörterbuch Segment für Segment ([key.split('.')]), anstatt das Wörterbuch einmalig abzuflachen, wie es [vue-i18n] intern tut – eine Wahl, die für die Größe dieser beiden Wörterbücher mehr als ausreichend ist.
5.8.2. assets/i18n/fr.json und assets/i18n/en.json
Unverändert übernommen aus [public/i18n/fr.json]/[en.json] (Client [Vue.js]), mit nur einer Änderung: Der Schlüssel [APP.TITLE] verweist nun auf „[Flutter]“ statt auf „[Vue.js]“. Beide Dateien müssen strukturell identisch bleiben (dieselben Schlüssel in beiden Sprachen) – so ist sichergestellt, dass ein Schlüssel in beiden Wörterbüchern existiert.
5.9. Die Schicht features

Ein Widget pro Funktion: der Anmeldebildschirm, die Auswahl eines Arztes und eines Tages, die Anzeige des Terminkalenders und der Dialog zur Terminbuchung.
5.9.1. lib/features/login/login_page.dart
Portierung von [src/app/features/login/Login.vue]: der Anmeldebildschirm.
| // =========================================================================
// features/login/login_page.dart
// -------------------------------------------------------------------------
// Port von src/app/features/login/Login.vue (Vue.js-Client dieses Kurses):
// der Anmeldebildschirm. Wie sein Vue.js-Gegenstück weiß dieses Widget
// nichts über den Terminkalender oder die Termine: Es sammelt lediglich ein
// Paar (login, password), gibt es an AuthService.logIn(...) weiter
// und zeigt einen eventuellen Fehler an.
//
// STRUKTURELLER UNTERSCHIED zu Vue.js: Login.vue deklariert seinen lokalen Zustand
// (login, password, submitting, error) mit einfachen ref(...) - Vue.js
// "zeichnet" dann das <template> automatisch neu, wenn sich eines dieser Refs
// ändert, OHNE jeden Begriff eines "Widgets mit oder ohne Zustand". Flutter unterscheidet
// explizit zwei Arten von Widgets: StatelessWidget (nichts ändert sich je
// nach der Konstruktion) und StatefulWidget (besitzt einen veränderlichen Zustand
// und kann sich über setState(...) neu zeichnen). Diese Komponente muss
// sich merken, was der Benutzer eintippt, UND sich neu zeichnen können, wenn
// submitting/error sich ändern: Sie ist also ein StatefulWidget - die
// Klasse LoginPage unten deklariert NUR createState(), der gesamte Zustand und
// die gesamte Logik liegen in _LoginPageState, der zugehörigen "Zwillings"-
// Klasse.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../../core/i18n/translations_service.dart';
import '../../core/services/auth_service.dart';
class LoginPage extends StatelessWidget {
const LoginPage({super.key});
@override
Widget build(BuildContext context) {
return const _LoginForm();
}
}
class _LoginForm extends StatefulWidget {
const _LoginForm();
@override
State<_LoginForm> createState() => _LoginFormState();
}
class _LoginFormState extends State<_LoginForm> {
// TextEditingController: Anders als v-model="login" auf der Vue.js-Seite
// (das ein Feld direkt in beide Richtungen an ein ref bindet, in einem
// einzigen Attribut), hat Flutter kein in das
// Widget TextField eingebautes Two-Way-Binding - man muss explizit einen Controller besitzen,
// ihn lesen (controller.text) und FREIGEBEN (dispose()), sobald das Widget
// zerstört wird, siehe dispose() unten. Das ist einmalig aufwendiger zu schreiben,
// macht aber einen Lebenszyklus explizit (Erzeugung -> Lesen -> Freigabe
// der Ressourcen), den Vue.js für ein ref selbst im Hintergrund verwaltet.
final TextEditingController _loginController = TextEditingController();
final TextEditingController _passwordController = TextEditingController();
bool _submitting = false;
String? _error;
@override
void dispose() {
// gibt die den Controllern zugeordneten Ressourcen frei - das Vergessen würde
// bei jeder Neuerstellung dieses Bildschirms ein Speicherleck verursachen.
// Vue.js, dessen ref() einfache JavaScript-Objekte sind, die wie jedes andere Objekt vom Garbage Collector
// eingesammelt werden,
// kennt keinen solchen vorzusehenden Schritt.
_loginController.dispose();
_passwordController.dispose();
super.dispose();
}
Future<void> _onSubmit() async {
final login = _loginController.text.trim();
final password = _passwordController.text;
if (login.isEmpty || password.isEmpty) {
return;
}
setState(() {
_error = null;
_submitting = true;
});
try {
// context.read<AuthService>(): ein "einmaliges" Lesen, OHNE erneutes Abonnieren
// künftiger Änderungen (anders als context.watch<...>(), siehe
// lib/app.dart) - genau passend für einen einmaligen, durch
// eine Benutzeraktion ausgelösten Aufruf, statt für eine Anzeige, die
// aktuell bleiben muss. Es ist das Flutter/provider-Äquivalent von
// "const auth = useAuth();" auf der Vue.js-Seite, wo auth.logIn(...)
// einfach ohne besondere Unterscheidung aufgerufen wird (Vue.js kennt diese Unterscheidung
// zwischen einmaligem Lesen und erneutem Abonnieren nicht: useAuth() liefert immer
// dasselbe reaktive Objekt, unabhängig von der Verwendung).
await context.read<AuthService>().logIn(login, password);
if (!mounted) return; // Das Widget kann während des Wartens auf den Server zerstört worden sein
setState(() => _submitting = false);
} catch (_) {
if (!mounted) return;
setState(() {
_submitting = false;
_error = 'LOGIN.ERROR';
});
}
}
@override
Widget build(BuildContext context) {
// context.watch<TranslationsService>(): Anders als
// context.read<AuthService>(), das oben in _onSubmit() verwendet wird,
// soll HIER dieses Widget sich automatisch neu zeichnen, wenn sich die Sprache
// ändert (FR/EN-Buttons von lib/app.dart) - watch() abonniert
// künftige Änderungen, wo read() nur einmalig liest.
final t = context.watch<TranslationsService>().t;
return Center(
child: ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 420),
child: Card(
child: Padding(
padding: const EdgeInsets.all(24),
// Form fasst die Felder zusammen und erlaubt das Absenden durch Drücken von
// "Enter" in jedem von ihnen (onFieldSubmitted
// unten) - das Äquivalent von <form @submit.prevent="onSubmit">
// in Login.vue: Enter in einem Feld UND ein Klick auf den Button
// lösen beide dasselbe onSubmit() aus.
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text(t('LOGIN.TITLE'), style: Theme.of(context).textTheme.titleLarge),
const SizedBox(height: 16),
if (_error != null) ...[
Container(
padding: const EdgeInsets.all(8),
decoration: BoxDecoration(
color: Theme.of(context).colorScheme.errorContainer,
borderRadius: BorderRadius.circular(4),
),
child: Text(
t(_error!),
style: TextStyle(color: Theme.of(context).colorScheme.onErrorContainer),
),
),
const SizedBox(height: 16),
],
TextField(
controller: _loginController,
decoration: InputDecoration(labelText: t('LOGIN.LOGIN_LABEL')),
textInputAction: TextInputAction.next,
),
const SizedBox(height: 12),
TextField(
controller: _passwordController,
decoration: InputDecoration(labelText: t('LOGIN.PASSWORD_LABEL')),
obscureText: true,
textInputAction: TextInputAction.done,
// onSubmitted: ausgelöst durch die Taste "Enter" (oder ihr
// Äquivalent auf der virtuellen Smartphone-Tastatur) - das Gegenstück zu
// @submit.prevent am Tag <form> auf der Vue.js-Seite,
// hier direkt am LETZTEN Feld des Formulars platziert.
onSubmitted: (_) => _onSubmit(),
),
const SizedBox(height: 20),
FilledButton(
onPressed: _submitting ? null : _onSubmit,
child: Text(_submitting ? t('LOGIN.SUBMITTING') : t('LOGIN.SUBMIT')),
),
const SizedBox(height: 16),
Text(
'${t('LOGIN.DEMO_ACCOUNTS_PREFIX')} admin / admin ${t('LOGIN.DEMO_ACCOUNTS_ADMIN')} '
'${t('LOGIN.DEMO_ACCOUNTS_OR')} user / user ${t('LOGIN.DEMO_ACCOUNTS_USER')}.',
style: Theme.of(context).textTheme.bodySmall,
),
],
),
),
),
),
);
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 39–44: [LoginPage] (ein einfaches [StatelessWidget] als Frontend) delegiert ALLES an [_LoginForm]/[_LoginFormState] – der Kopfkommentar erläutert, warum dieser Bildschirm, der speichern muss, was der Benutzer eingibt, UND sich neu zeichnen muss, wenn sich [_submitting]/[_error] ändern, NICHT einfach ein [StatelessWidget] sein kann, anders als [Login.vue], wo [ref(...)] eine solche Unterscheidung nicht kennt.
- Zeilen 55–56: [final TextEditingController _loginController = TextEditingController();] – ersetzt [v-model="login"]: keine eingebaute bidirektionale Bindung bei [TextField]; ein Controller muss ausdrücklich angegeben werden.
- Zeilen 61–71: [dispose() { _loginController.dispose(); _passwordController.dispose(); ... }] – gibt beide Controller frei; ein Versäumnis an dieser Stelle würde bei jeder Neuerstellung dieses Bildschirms ein Speicherleck verursachen, ein Schritt, den [Vue.js] nicht berücksichtigen muss (dessen [ref()]-Objekte werden schlicht vom Garbage Collector eingesammelt).
- Zeilen 93–102: [await context.read<AuthService>().logIn(login, password);] innerhalb eines [try/catch] – [context.read<...>()] (einmaliges Lesen, OHNE erneutes Abonnieren) statt [context.watch<...>()] (siehe [lib/app.dart]), das sich gut für einen einmaligen, durch eine Benutzeraktion ausgelösten Aufruf eignet.
- Zeile 160: [onSubmitted: (_) => _onSubmit(),] am LETZTEN Feld (Passwort) platziert – das Gegenstück zu [@submit.prevent="onSubmit"], das auf der Seite von [Vue.js] am [<form>]-Tag gesetzt wird: Das Drücken der Eingabetaste im Feld UND das Klicken auf die Schaltfläche lösen beide dasselbe [_onSubmit()] aus.
5.9.2. lib/features/doctor_day_picker/doctor_day_picker.dart
Portierung von [src/app/features/doctor-day-picker/DoctorDayPicker.vue]: Auswahl eines Arztes und eines Datums, anschließend Anforderung seines Terminkalenders.
| // =========================================================================
// features/doctor_day_picker/doctor_day_picker.dart
// -------------------------------------------------------------------------
// Port von src/app/features/doctor-day-picker/DoctorDayPicker.vue (Vue.js-
// Client dieses Kurses): das Widget zur Auswahl eines Arztes und eines
// Tages, um dann dessen Terminkalender anzufordern.
//
// Ein Vue.js-[defineProps]/[defineEmits] (Props als Eingaben, Ereignisse als
// Ausgaben) wird hier ganz direkt zu einem Dart-KONSTRUKTOR: Die Props
// sind die benannten Parameter des Konstruktors (doctors, onSearch), und
// ein "Ereignis auszulösen" wird einfach zum AUFRUF der als
// Parameter erhaltenen Funktion - genau die Wahl, die bereits der React-Client
// dieses Kurses getroffen hat (eine Funktions-Prop, onSearch), statt der
// für Vue.js spezifischen expliziten Deklaration [defineEmits]. Flutter macht wie React
// KEINEN syntaktischen Unterschied zwischen "normaler Prop" und "Prop zum
// Benachrichtigen des Elternteils": Es ist eine Funktion wie jede andere, die vom
// Elternteil übergeben wird (siehe lib/app.dart), wenn dieses Widget gebaut wird.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import 'package:provider/provider.dart';
import '../../core/i18n/translations_service.dart';
import '../../core/models/appointment_models.dart';
// Format "yyyy-MM-dd" - dasselbe Datumsformat wie auf der Vue.js-Seite
// (new Date().toISOString().slice(0, 10)), aber hier explizit über das Paket intl
// gebaut statt durch Abschneiden des Strings: Dart-DateTime
// hat keine eingebaute Methode toISOString().
final DateFormat _dayFormat = DateFormat('yyyy-MM-dd');
class DoctorDayPicker extends StatefulWidget {
final List<Doctor> doctors;
// onSearch(doctorId, day): das direkte Äquivalent von
// "search: [criteria: { doctorId: number; day: string }]" auf der
// Vue.js-Seite - hier zwei Positionsparameter statt eines einzelnen Objekts
// {doctorId, day}, eine in Dart ebenso gültige Wahl wie die andere.
final void Function(int doctorId, String day) onSearch;
const DoctorDayPicker({super.key, required this.doctors, required this.onSearch});
@override
State<DoctorDayPicker> createState() => _DoctorDayPickerState();
}
class _DoctorDayPickerState extends State<DoctorDayPicker> {
// rein lokaler Zustand dieses Widgets (was in den Menüs ausgewählt ist,
// solange der Benutzer den Button nicht angeklickt hat) - das direkte
// Äquivalent von selectedDoctorId/selectedDay auf der Vue.js-Seite, als
// einfache Felder von _DoctorDayPickerState statt ref(...): Ein
// Flutter-StatefulWidget braucht für
// ein lokales Feld keine besondere "Umhüllung", setState(...) (siehe _onDoctorChoice unten) genügt,
// um zu signalisieren, dass ein Neuzeichnen nötig ist.
int? _selectedDoctorId;
DateTime _selectedDay = DateTime.now();
Future<void> _pickDay() async {
// Flutter hat kein direktes Äquivalent zu <input type="date"> (ein
// Datumseingabe-Widget, das NATIV IM BROWSER vorhanden ist und von dem Vue.js
// im Web profitieren konnte): In den 3 von diesem Client anvisierten Umgebungen
// (mobil, Desktop, Web) zeichnet Flutter SELBST den
// Datumsauswahldialog (showDatePicker(...) unten) - ein
// Material-Widget, das in den 3 Zielumgebungen gleich aussieht. Es ist eine
// sehr konkrete Veranschaulichung des Versprechens "eine einzige Codebasis für 3
// Umgebungen": Wo Vue.js sich auf einen Baustein
// des Browsers stützte (der auf Mobilgeräten und Desktop fehlt), liefert Flutter seinen
// eigenen Baustein, der ÜBERALL verfügbar ist.
final picked = await showDatePicker(
context: context,
initialDate: _selectedDay,
firstDate: DateTime(2020),
lastDate: DateTime(2100),
);
if (picked != null) {
setState(() => _selectedDay = picked);
}
}
void _onSearchClick() {
final doctorId = _selectedDoctorId;
if (doctorId == null) {
return; // der Button ist in diesem Fall ohnehin deaktiviert (siehe build() unten)
}
// widget.onSearch(...): Die vom Elternteil erhaltene Funktion wird aufgerufen -
// genau das Äquivalent von emit('search', ...) auf der Vue.js-Seite oder des
// Aufrufs der Prop onSearch(...) auf der React-Seite. Das Präfix "widget."
// ist hier nötig, weil _DoctorDayPickerState eine von DoctorDayPicker
// GETRENNTE Klasse ist (siehe den Kopf von lib/features/login/login_page.dart
// für den Grund dieser Flutter-spezifischen Trennung von State und Widget):
// So greift man vom State aus auf die Parameter des Widgets zu,
// dem er gehört.
widget.onSearch(doctorId, _dayFormat.format(_selectedDay));
}
@override
Widget build(BuildContext context) {
final t = context.watch<TranslationsService>().t;
// Die drei Felder werden hier NUR EINMAL gebaut und dann vom
// weiter unten stehenden LayoutBuilder angeordnet: nebeneinander (Row) auf einem breiten Bildschirm,
// übereinander (Column) auf einem schmalen Bildschirm. Ein Smartphone im Hochformat ist nur
// etwa 360 Pixel breit: Drei Felder nebeneinander hätten dort jeweils
// nur etwa hundert Pixel und würden überlaufen.
//
// DropdownButtonFormField<int>: das Flutter-Äquivalent eines
// HTML-<select> - anders als v-model="selectedDoctorId"
// auf der Vue.js-Seite (ein einziges Two-Way-Binding) trennt Flutter
// explizit "angezeigten Wert" (value:) und "Reaktion
// auf eine Änderung" (onChanged:), nach Art von React
// (:value + @change), die bereits
// in der ursprünglichen .vue-Datei verglichen wurde.
final doctorField = DropdownButtonFormField<int>(
// isExpanded: Das Label nimmt die gesamte verfügbare Breite ein (und wird
// sauber abgeschnitten, wenn es zu lang ist), statt überzulaufen.
isExpanded: true,
decoration: InputDecoration(labelText: t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')),
value: _selectedDoctorId,
hint: Text(t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')),
// .map(...).toList(): das Flutter-Äquivalent von
// v-for="doctor in doctors" :key="doctor.id" - hier ist
// der "stabile" Bezeichner (:key auf der Vue.js-Seite) einfach
// der [value:] jedes DropdownMenuItem (doctor.id), den
// Flutter selbst verwendet, um zu wissen, welcher
// gerade ausgewählt ist.
items: widget.doctors
.map(
(doctor) => DropdownMenuItem(
value: doctor.id,
child: Text('${doctor.title} ${doctor.firstName} ${doctor.lastName}'),
),
)
.toList(),
onChanged: (id) => setState(() => _selectedDoctorId = id),
);
// InkWell: macht den gesamten Bereich "anklickbar" - ein Tippen
// irgendwo darauf öffnet den Datumsauswahldialog
// (_pickDay oben). Es ist ein Nachbau von Hand dessen, was der Browser "kostenlos" mit
// <input type="date" v-model="selectedDay"> auf der Vue.js-Seite bot.
// InputDecorator (statt eines "getarnten" TextField) zeigt
// das Datum an, ohne einen TextEditingController zu besitzen - hier gibt es
// NICHTS per Tastatur einzutippen, nur einen Wert
// anzuzeigen und ein Tippen abzufangen:
// Der Lebenszyklus aus
// Erzeugen/dispose, der bereits in
// lib/features/login/login_page.dart für ein wirklich editierbares Feld auftrat, ist nicht nötig.
final dayField = InkWell(
onTap: _pickDay,
child: InputDecorator(
decoration: InputDecoration(labelText: t('DOCTOR_DAY_PICKER.DAY_LABEL')),
child: Text(_dayFormat.format(_selectedDay)),
),
);
final scheduleButton = FilledButton(
onPressed: _selectedDoctorId == null ? null : _onSearchClick,
child: Text(t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE')),
);
return Card(
child: Padding(
padding: const EdgeInsets.all(16),
// LayoutBuilder: ruft seinen Builder mit der an dieser Stelle des Baums TATSÄCHLICH
// verfügbaren Breite auf (constraints.maxWidth) und
// ruft ihn erneut auf, wenn sie sich ändert (Bildschirmdrehung, Größenänderung
// des Fensters) - das Layout passt sich also von selbst an.
child: LayoutBuilder(
builder: (context, constraints) {
if (constraints.maxWidth < 600) {
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
doctorField,
const SizedBox(height: 12),
dayField,
const SizedBox(height: 12),
scheduleButton,
],
);
}
return Row(
crossAxisAlignment: CrossAxisAlignment.end,
children: [
Expanded(flex: 5, child: doctorField),
const SizedBox(width: 12),
Expanded(flex: 4, child: dayField),
const SizedBox(width: 12),
Expanded(flex: 3, child: scheduleButton),
],
);
},
),
),
);
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 59–79: [_pickDay()] ruft [showDatePicker(...)] auf – eine sehr konkrete Veranschaulichung des Versprechens „ein einziger Code für drei Umgebungen“: Während [Vue.js] auf [<input type="date">] setzte, einen NATIVEN Baustein des BROWSERS (auf Mobilgeräten und Desktop nicht vorhanden), [Flutter] zeichnet SELBST eine Auswahl, die ein [Material]-Widget ist und auf allen drei Zielplattformen völlig identisch aussieht.
- Zeilen 114–136: [DropdownButtonFormField<int>(value: _selectedDoctorId, ..., onChanged: (id) => setState(() => _selectedDoctorId = id))] – ersetzt [v-model="selectedDoctorId"] durch ein explizites Paar [value:]/[onChanged:], ähnlich dem Paar [:value]/[@change] , dem wir in diesem Kurs bereits im Zusammenhang mit [React] begegnet sind.
- Zeilen 149–155: [InkWell(onTap: _pickDay, child: InputDecorator(...))] – von Hand nachgebaut aus dem, was der Browser mit [<input type="date">] „gratis“ lieferte; [InputDecorator] (statt eines „verkleideten“ [TextField]) zeigt das Datum OHNE [TextEditingController] an.
- Zeilen 169–194: [LayoutBuilder(builder: (context, constraints) { ... })] – die Antwort von [Flutter] auf einen Bildschirm unbekannter Breite: [builder] erhält die an dieser Stelle tatsächlich verfügbare Breite ([constraints.maxWidth]) und wird erneut aufgerufen, wenn sie sich ändert (Bildschirmdrehung, Größenänderung des Fensters). Unterhalb von 600 Pixeln – ein Smartphone im Hochformat ist nur etwa 360 Pixel breit – werden die drei Felder in einer [Column] GESTAPELT; darüber stehen sie nebeneinander in einer [Row]. Die drei Felder werden vorher einmalig in den Variablen [doctorField], [dayField] und [scheduleButton] erstellt: Nur ihr Layout ändert sich. Mit der [Row] der ersten Version hätte jedes Feld auf einem Smartphone im Hochformat nur etwa hundert Pixel zur Verfügung gehabt, und der Inhalt wäre übergelaufen (das gelb-schwarze Banner „RIGHT OVERFLOWED BY … PIXELS“ im Debug-Modus); [isExpanded: true] in der Dropdown-Liste verhindert denselben Überlauf bei einem langen Namen eines Arztes.
5.9.3. lib/features/schedule/schedule_view.dart
Portierung von [src/app/features/schedule/Schedule.vue]: der Terminkalender eines Arztes für einen bestimmten Tag – freie Zeitfenster (Schaltfläche „Buchen“) oder gebuchte Zeitfenster (Patient + Schaltfläche „Stornieren“).
| // =========================================================================
// features/schedule/schedule_view.dart
// -------------------------------------------------------------------------
// Port von src/app/features/schedule/Schedule.vue (Vue.js-Client dieses
// Kurses): zeigt den Terminkalender eines Arztes für einen bestimmten Tag an - die Liste
// seiner Zeit-Slots, jeder entweder frei (Button "Book") oder gebucht
// (Name des Patienten + Button "Cancel").
//
// Seit der Einführung der Authentifizierung erhält dieses Widget zudem
// canEdit: Wenn false (Rolle USER), verschwinden die Buttons "Book"/"Cancel" -
// der Terminkalender kann weiterhin eingesehen werden, aber nur lesend (der
// Server würde diese Aktionen für einen USER ohnehin verweigern, 403 Forbidden,
// siehe RolesGuard auf der Serverseite).
//
// [v-if]/[v-else] und [v-for] (Vue.js) werden hier zu GEWÖHNLICHEN Dart-Ausdrücken:
// Flutter kennt, wie zuvor React (siehe den Kommentar zu
// Schedule.vue), KEINE von der Programmiersprache getrennte "Template-Sprache" -
// const/if/for und die Operatoren ?./?? von normalem Dart
// genügen, um Bedingungen und Listen direkt in der
// Methode build(...) unten auszudrücken.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../../core/i18n/translations_service.dart';
import '../../core/models/appointment_models.dart';
class ScheduleView extends StatelessWidget {
final DoctorDaySchedule? schedule;
final bool canEdit;
final void Function(SlotJson slot) onBook;
final void Function(AppointmentJson appointment) onCancel;
const ScheduleView({
super.key,
required this.schedule,
required this.canEdit,
required this.onBook,
required this.onCancel,
});
// kleine Formatierungs-Hilfsfunktion, "8:05" statt "8:5" -
// vom Geist her identisch mit formatTime(...) auf der Vue.js-Seite.
static String _formatTime(int h, int m) => '$h:${m.toString().padLeft(2, '0')}';
void _onSlotClick(DoctorDaySlot daySlot) {
if (!canEdit) {
return; // Der Button wird in diesem Fall ohnehin nicht angezeigt (siehe build() unten)
}
final appointment = daySlot.appointment;
if (appointment == null) {
onBook(daySlot.slot); // freier Slot: Buchung anbieten
} else {
onCancel(appointment); // bereits gebuchter Slot: Stornierung des bestehenden Termins anbieten
}
}
@override
Widget build(BuildContext context) {
final t = context.watch<TranslationsService>().t;
final schedule = this.schedule;
if (schedule == null) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: 24),
child: Text(
t('SCHEDULE.EMPTY_STATE'),
style: TextStyle(color: Theme.of(context).colorScheme.outline),
),
);
}
return Card(
child: Padding(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'${t('SCHEDULE.TITLE_PREFIX')} ${schedule.day} - ${schedule.doctor.title} '
'${schedule.doctor.firstName} ${schedule.doctor.lastName}',
style: Theme.of(context).textTheme.titleMedium,
),
const SizedBox(height: 12),
// DataTable: das Flutter-Material-Äquivalent der HTML-<table>
// von Schedule.vue - anders als bei HTML müssen ihre Zeilen
// in Dart explizit über .map(...).toList() gebaut werden
// (auch hier das Äquivalent von v-for="daySlot in
// schedule.slots" :key="daySlot.slot.id" - die DataRow
// braucht keinen expliziten "key" wie in Vue.js/React: Die
// Liste wird bei jedem Rendern vollständig neu aufgebaut, Flutter versucht hier nicht,
// vorhandene Zeilen wiederzuverwenden).
SingleChildScrollView(
scrollDirection: Axis.horizontal,
child: DataTable(
columns: [
DataColumn(label: Text(t('SCHEDULE.COLUMN_SLOT'))),
DataColumn(label: Text(t('SCHEDULE.COLUMN_STATUS'))),
const DataColumn(label: Text('')),
],
rows: schedule.slots.map((daySlot) {
final appointment = daySlot.appointment;
final slot = daySlot.slot;
return DataRow(
// leicht getönter Hintergrund für einen freien Slot - das
// Gegenstück zur CSS-Klasse "free-slot" auf der Vue.js-Seite.
color: appointment == null
? WidgetStateProperty.all(Theme.of(context).colorScheme.surfaceContainerLow)
: null,
cells: [
DataCell(Text(
'${_formatTime(slot.startHour, slot.startMinute)} - '
'${_formatTime(slot.endHour, slot.endMinute)}',
)),
DataCell(
appointment == null
? Chip(
label: Text(t('SCHEDULE.FREE')),
backgroundColor: Colors.green.shade100,
)
: Chip(
label: Text('${appointment.client?.title ?? ''} ${appointment.client?.firstName ?? ''} ${appointment.client?.lastName ?? ''}'),
),
),
DataCell(
// canEdit: false für eine Rolle USER (nur lesend)
canEdit
? OutlinedButton(
onPressed: () => _onSlotClick(daySlot),
child: Text(appointment == null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')),
)
: const SizedBox.shrink(),
),
],
);
}).toList(),
),
),
],
),
),
);
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 43–57: [_formatTime(h, m)] und [_onSlotClick(daySlot)] – Letztere unterscheidet zwischen einem freien Zeitfenster ([onBook(...)]) und einem gebuchten Zeitfenster ([onCancel(...)]), je nachdem, ob [daySlot.appointment] [null] ist oder nicht, genau dieselbe Logik wie auf der Seite von [Vue.js], aber rein in [Dart] ausgedrückt statt in [<template>].
- Zeilen 96–137: [DataTable(columns: [...], rows: schedule.slots.map((daySlot) { ... }).toList())] – das [Material]-Äquivalent zur [<table>] [HTML] -Tabelle aus [Schedule.vue]: Ihre Zeilen müssen ausdrücklich über [.map(...).toList()] aufgebaut werden.
- Zeilen 108–110: [color: appointment == null ? WidgetStateProperty.all(Theme.of(context).colorScheme.surfaceContainerLow) : null,] – das Gegenstück zur [CSS]-Klasse ["free-slot"] auf der Seite von [Vue.js]: eine Hintergrundfarbe, die bedingt auf die gesamte Zeile angewendet wird, hier über eine Funktion statt über eine benannte [CSS]-Klasse.
5.9.4. lib/features/booking_dialog/booking_dialog.dart
Portierung von [src/app/features/booking-dialog/BookingDialog.vue]: die Auswahl eines Patienten, um ein freies Zeitfenster zu reservieren – die Datei, in der der strukturelle Unterschied zu [Vue.js] in diesem gesamten Client am deutlichsten ausfällt.
| // =========================================================================
// features/booking_dialog/booking_dialog.dart
// -------------------------------------------------------------------------
// Port von src/app/features/booking-dialog/BookingDialog.vue (Vue.js-
// Client dieses Kurses): das (modale) Fenster zur Auswahl eines
// Patienten, um einen freien Slot zu buchen.
//
// WICHTIGER STRUKTURELLER UNTERSCHIED zu Vue.js (und zu den drei anderen
// Widgets von lib/features/): BookingDialog.vue ist eine Komponente, die IMMER
// im Baum VORHANDEN ist und deren Prop [open] (ein von
// App.vue gehaltener Boolean) lediglich die Anzeige steuert (v-if="open") - GENAU dieselbe
// Wahl wie bei den Angular- und React-Clients dieses Kurses, motiviert durch das Anliegen,
// Vue.js und das JavaScript von Bootstrap daran zu hindern, um
// dieselbe Information zu streiten ("ist das Modal geöffnet?").
//
// Flutter hat dieses Problem nicht: Ein Dialogfeld IST KEIN Widget,
// das im Baum bedingt ein- oder ausgeblendet wird, sondern eine ECHTE
// SEITE, die beim Öffnen mit showDialog(...) auf den Navigationsstapel
// (den Navigator) gelegt
// und beim Schließen automatisch wieder entfernt wird. Es gibt hier also WEDER einen Zustand "open: bool" im
// Eltern-Widget (siehe lib/app.dart, das kein Feld hat, das
// slotBeingBooked auf der Vue.js-Seite entspricht), NOCH Ereignisse "confirm"/"close", die
// auszulösen wären: showDialog(...) liefert ein Future, das mit dem
// an Navigator.pop(...) übergebenen Wert abgeschlossen wird - null, wenn der Benutzer
// ohne Auswahl geschlossen hat, andernfalls die ID des gewählten Patienten. Es ist das
// AUFRUFENDE Widget (lib/app.dart), das dieses Future abwartet, um zu wissen, was
// danach zu tun ist - eine vollständige Umkehrung der Kommunikationsrichtung
// im Vergleich zu den beiden Vue.js-Ereignissen.
// =========================================================================
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../../core/i18n/translations_service.dart';
import '../../core/models/appointment_models.dart';
// -----------------------------------------------------------------------
// Hilfsfunktion: öffnet das Dialogfeld und liefert die ID des
// gewählten Patienten zurück (oder null, wenn der Benutzer abgebrochen/ohne Auswahl geschlossen hat).
// DIESE Funktion ruft lib/app.dart auf - niemals direkt den
// Konstruktor von _BookingDialogContent unten.
// -----------------------------------------------------------------------
Future<int?> openBookingDialog({
required BuildContext context,
required SlotJson slot,
required List<Client> clients,
}) {
return showDialog<int>(
context: context,
builder: (_) => _BookingDialogContent(slot: slot, clients: clients),
);
}
class _BookingDialogContent extends StatefulWidget {
final SlotJson slot;
final List<Client> clients;
const _BookingDialogContent({required this.slot, required this.clients});
@override
State<_BookingDialogContent> createState() => _BookingDialogContentState();
}
class _BookingDialogContentState extends State<_BookingDialogContent> {
int? _selectedClientId;
void _onConfirmClick() {
final clientId = _selectedClientId;
if (clientId == null) {
return;
}
// Navigator.pop(context, clientId): schließt das Dialogfeld UND
// übergibt clientId als Ergebnis des von
// openBookingDialog(...) zurückgegebenen Futures - das Äquivalent, in einem einzigen Aufruf, von
// emit('confirm', { clientId }) GEFOLGT vom Schließen (implizit,
// vom Elternteil über [open] gesteuert) auf der Vue.js-Seite.
Navigator.pop(context, clientId);
}
void _onCloseClick() {
// Navigator.pop(context) ohne zweites Argument: Das von
// openBookingDialog(...) zurückgegebene Future wird mit null abgeschlossen - das Äquivalent von
// emit('close') auf der Vue.js-Seite.
Navigator.pop(context);
}
@override
Widget build(BuildContext context) {
final t = context.watch<TranslationsService>().t;
final slot = widget.slot;
// AlertDialog: das Material-Widget für Dialogfelder -
// liefert von sich aus bereits den abgedunkelten Hintergrund (das Äquivalent des
// .modal-backdrop, der auf der Vue.js-Seite "von Hand" gesetzt wurde) und das
// standardmäßige Schließverhalten (Tippen außerhalb des Feldes, Escape-Taste
// auf Desktop/Web) - ein Verhalten, das der Vue.js-Client selbst
// nachbauen musste, da Bootstrap nur einen Teil davon automatisch behandelt.
return AlertDialog(
title: Text(t('BOOKING_DIALOG.TITLE')),
content: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'${t('BOOKING_DIALOG.SLOT_FROM')} ${slot.startHour}:${slot.startMinute.toString().padLeft(2, '0')} '
'${t('BOOKING_DIALOG.SLOT_TO')} ${slot.endHour}:${slot.endMinute.toString().padLeft(2, '0')}',
),
const SizedBox(height: 16),
DropdownButtonFormField<int>(
decoration: InputDecoration(labelText: t('BOOKING_DIALOG.PATIENT_LABEL')),
value: _selectedClientId,
hint: Text(t('BOOKING_DIALOG.CHOOSE_PATIENT')),
items: widget.clients
.map(
(client) => DropdownMenuItem(
value: client.id,
child: Text('${client.title} ${client.firstName} ${client.lastName}'),
),
)
.toList(),
onChanged: (id) => setState(() => _selectedClientId = id),
),
],
),
actions: [
TextButton(onPressed: _onCloseClick, child: Text(t('BOOKING_DIALOG.CANCEL'))),
FilledButton(
onPressed: _selectedClientId == null ? null : _onConfirmClick,
child: Text(t('BOOKING_DIALOG.CONFIRM')),
),
],
);
}
}
|
Lassen Sie uns diesen Code kommentieren:
- Zeilen 16–28: Der Kopfkommentar fasst den bedeutsamsten strukturellen Unterschied in dieser Datei zusammen – [BookingDialog.vue] ist eine Komponente, die IMMER im Baum VORHANDEN ist und deren Anzeige allein durch eine boolesche Eigenschaft ([open], gehalten von [App.vue]) gesteuert wird; ein Dialog in [Flutter] ist dagegen NIE vorhanden, bis er ausdrücklich mit [showDialog(...)] geöffnet wird – eine echte Seite, die auf den Navigationsstapel gelegt und beim Schließen automatisch wieder entfernt wird.
- Zeilen 43–52: [Future<int?> openBookingDialog({...}) { return showDialog<int>(context: context, builder: (_) => _BookingDialogContent(...)); }] – die Funktion, die von [lib/app.dart] aufgerufen wird; ihr Rückgabetyp ([Future<int?>]) zeigt bereits an, dass SIE irgendwann entweder die ID des ausgewählten Patienten oder [null] zurückgibt.
- Zeilen 67–77: [Navigator.pop(context, clientId);] – schließt den Dialog UND gibt [clientId] als Ergebnis des [Future] zurück, das von [openBookingDialog(...)] geliefert wurde – das Äquivalent, in einem einzigen Aufruf, dessen, was [emit('confirm', { clientId })] GEFOLGT von einem vom Elternelement gesteuerten Schließen auf der Seite von [Vue.js] ZUSAMMEN leisteten.
- Zeilen 80–84: [Navigator.pop(context);] ohne zweites Argument – [Future] endet dann mit [null], was [emit('close')] auf der Seite von [Vue.js] entspricht. Es ist [lib/app.dart] ([_onBookingRequest(...)]), das mit [await] auf das [Future] wartet und entscheidet, was zu tun ist, je nachdem, ob das Ergebnis [null] ist oder nicht – eine vollständige Umkehr der Kommunikationsrichtung im Vergleich zu den beiden Vue.js-Ereignissen.
5.10. Schritt-für-Schritt-Anleitung zur Verwendung der Flutter-Web-App
5.10.1. 1. Anmeldebildschirm
Beim ersten Laden ist keine Sitzung in [shared_preferences] gespeichert: [AuthService.isLoggedIn] ist gleich [false], und [AppRoot] zeigt [LoginPage] an. Ein Versuch mit einer ungültigen Kombination aus Benutzername und Passwort zeigt die von [_LoginFormState] gespeicherte Fehlermeldung an (Schlüssel [LOGIN.ERROR]). Die Auswahl FR/EN, die sichtbar bleibt, übersetzt auch diesen Bildschirm.
| PS C:\Data\st-2026\dev\flutter-nestjs-sept-2026\rdvmedecins_flutter_client> flutter devices
Found 4 connected devices:
sdk gphone16k x86 64 (mobile) • emulator-5554 • android-x64 • Android 17 (API 37) (emulator)
Windows (desktop) • windows • windows-x64 • Microsoft Windows [version
10.0.26200.9457]
Chrome (web) • chrome • web-javascript • Google Chrome 153.0.8010.48
Edge (web) • edge • web-javascript • Microsoft Edge 153.0.4234.48
Run "flutter emulators" to list and start any available device emulators.
If you expected another device to be detected, please run "flutter doctor" to diagnose potential issues. You
may also try increasing the time to wait for connected devices with the "--device-timeout" flag. Visit
https://flutter.dev/setup/ for troubleshooting tips.
PS C:\Data\st-2026\dev\flutter-nestjs-sept-2026\rdvmedecins_flutter_client> flutter run -d edge
|

5.10.2. 2. Als Administrator anmelden (Rolle ADMIN, Vollzugriff)
Nach der Anmeldung mit [admin]/[admin] zeigt [AppRoot] nicht mehr [LoginPage] an und lädt die Ärzte/Clients ([_loadInitialLists()]). Nach der Auswahl eines Arztes und eines Datums in [DoctorDayPicker] wird der Terminkalender mit den sichtbaren Schaltflächen „Buchen“/„Stornieren“ angezeigt ([canEdit] entspricht für diese Rolle [true]). Ein Klick auf „Buchen“ öffnet den Dialog zur Patientenauswahl ([openBookingDialog(...)]); nach der Bestätigung ([AppointmentService.addAppointment(...)]) wird der Terminkalender neu geladen, und das Zeitfenster erscheint als gebucht. Ein Klick auf „Stornieren“ (bei einem gebuchten Zeitfenster) ruft direkt [AppointmentService.deleteAppointment(...)] auf und macht das Zeitfenster wieder verfügbar.

- in [1] die URL des NestJS-Servers (er muss gestartet sein);
- in [2-3] die Zugangsdaten des Administrators: admin / admin;
- in [4]: Anmeldung am Server;

- In [1] wählen Sie einen Arzt aus;
- in [2] wählen Sie einen Tag aus;
- In [3] sehen Sie den Terminkalender des ausgewählten Arztes für den gewählten Tag;
- In [1] nehmen Sie eine Buchung vor;

- In [1-2] wählen Sie einen Patienten aus und bestätigen;

- In [1] ist das Zeitfenster für den Termin gebucht;
- In [2] melden Sie sich ab. Sie gelangen zurück zum Anmeldebildschirm;
5.10.3. 3. Als Benutzer anmelden (Rolle USER, nur lesend)
Nach der Abmeldung zeigt die Anmeldung mit [user]/[user] ein Badge „USER“ an. Der Terminkalender bleibt einsehbar, aber es erscheinen keine Schaltflächen „Buchen“/„Stornieren“ ([canEdit] entspricht [false]) – der Server würde diese beiden Aktionen dieser Rolle ohnehin verweigern (403 Forbidden, siehe Kapitel 2).

Es ist nicht möglich, einen Termin hinzuzufügen oder zu löschen.
5.11. Was außerhalb des Umfangs bleibt oder zurückgestellt wurde
- Wie bei den Clients [Angular], [React] und [Vue.js] in diesem Kurs gibt es keinen eigenen Demo-/Debug-Modus (keinen Schalter „Offline-Modus“).
- Auf der Client-Seite werden zu Lehrzwecken keine künstlichen Netzwerkverzögerungen eingeführt – die beobachteten Antwortzeiten sind die tatsächlichen Antwortzeiten des [NestJS]-Servers.
- Kein Router: Wie bei den vier vorherigen Varianten passt die Anwendung auf einen einzigen Bildschirm (abgesehen vom Reservierungsdialog).
- Die von [flutter create] erzeugten nativen Projekte ([android/], [ios/], [macos/], [windows/], [linux/], [web/]) sind diesem Dokument nicht beigefügt (siehe Kapitel 1) – sie werden lokal neu erzeugt und sind für jedes [Flutter]-Quellprojekt identisch.