Skip to content

11. Fallstudie: Der Ionic-Client für die Anwendung RdvMedecins

11.1. Die Aufgabenstellung

Die Anwendung [RdvMedecins] ermöglicht es, Termine in einer Arztpraxis zu vereinbaren. Der [NestJS]-Kurs hat sie als HTML-Anwendung geschrieben, bei der der Server die Seiten erzeugte; die Kurse [Vue.js], [Angular] und [React] haben dafür Web-Clients geschrieben, die dieselben Seiten im Browser aus den JSON-Daten des Servers erzeugen, die im Kapitel „Der RdvMedecins-Server, eine Blackbox“ beschrieben sind; der [Flutter]-Kurs hat einen mobilen Client entwickelt. Hier entwickeln wir den [Ionic]-Client: eine mobile App ([Android]), erstellt mit [Angular] und [Capacitor], die OHNE Änderungen AUCH eine Web-App ist.

Der Client muss alles bieten, was die anderen boten:

  • einen Anmeldebildschirm, durch ein CAPTCHA geschützt, mit der Möglichkeit, ein Patientenkonto anzulegen;
  • den Terminkalender eines Arztes für einen bestimmten Tag, mit Terminbuchung (Fenster zur Patientenauswahl) und Stornierung;
  • für den Administrator die Verwaltung von Ärzten und Kunden (auflisten, hinzufügen, bearbeiten, löschen);
  • für den Patienten einen persönlichen Bereich (mit den bevorstehenden Terminen, die er stornieren kann) und die Kontoverwaltung;
  • zwei Sprachen: Französisch und Englisch;
  • dieselben Adressen wie die Web-Clients ([/schedule?doctorId=1&day=...]). Auf dem Smartphone sind sie unsichtbar, ordnen aber die App; im Web können Benutzer sie neu laden, als Lesezeichen speichern und mit den Schaltflächen „Zurück“/„Vor“ des Browsers durch die App navigieren.

Eine mobile App bringt eigene Anforderungen mit: einen schmalen Bildschirm (keine Tabellen mit fünf Spalten), eine Tastatur, die die Hälfte des Bildschirms verdeckt, eine Zurück-Taste, einen Passwortmanager und HTTP-Anfragen, die nicht von einer vom Server ausgelieferten Webseite stammen (wo soll das Token-Cookie gespeichert werden?).

Das ist eine Gelegenheit, alles zusammenzuführen, was die Beispiele getrennt vorgestellt haben: Komponenten und Signale, Formulare, den Router und die Guards, den gemeinsamen Zustand, die Übersetzungen und die Kommunikation mit dem Server.

11.2. Installation und Ausführung

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

In einem Konsolenfenster, das im Ordner [rdvmedecins_ionic] geöffnet ist:

npm install
npm start
  • Zeile 1: lädt die Pakete des Projekts herunter (Ordner [node_modules]), beschrieben durch [package.json];
  • Zeile 2: startet [ng serve], den Entwicklungsserver von [Angular], unter der Adresse http://localhost:8100. Er leitet die /api-Anfragen an den JSON-Server weiter (Datei [proxy.conf.json], wie in den Beispielen 22 bis 25). Öffnen Sie diese URL in [Chrome], vorzugsweise mit den Entwicklerwerkzeugen (F12) im Modus „mobiles Gerät“ (Strg+Umschalt+M), in der Größe eines Smartphones.

Wie in den Beispielen wird jede Änderung einer Quelldatei sofort kompiliert und im Browser neu geladen.

Zum Ausprobieren unter [Android] (erfordert das [Android]-SDK und [Android Studio]; siehe das Kapitel „Einrichtung der Entwicklungsumgebung“):

1
2
3
4
npx cap add android
npx ng build
npx cap sync android
npx cap run android
  • Zeile 1: Nur einmal: Erzeugt das [Android Studio]-Projekt (Ordner [android/]). Mit dem JDK eines aktuellen [Android Studio] ([Java] 25) stellen wir das Projekt anschließend auf [Gradle] 9.1 um (Datei [android/gradle/wrapper/gradle-wrapper.properties], siehe Beispiel 01);
  • Zeile 2: kompiliert die Webanwendung nach [dist/rdvmedecins_ionic/browser/];
  • Zeile 3: kopiert sie in das [Android]-Projekt;
  • Zeile 4: führt sie im Emulator oder auf einem per USB angeschlossenen Smartphone aus (der Befehl fragt, welches von beiden gewählt werden soll). Der Emulator verbindet sich mit dem Server unter der Adresse [10.0.2.2:8080] (siehe Beispiel 22); für ein echtes Smartphone geben Sie beim Kompilieren die Adresse des Computers im WLAN an: [npx ng build --define "SERVER='http://192.168.1.20:8080'"] (siehe [config.ts]). Das Kapitel „Bereitstellung“ beschreibt diese Schritte im Detail.

Die Demo-Konten sind auf dem Anmeldebildschirm aufgeführt (Passwort = Login).

11.3. Die Anwendung benutzen

Die Screenshots in diesem Abschnitt stammen von einem Smartphone mit einer Auflösung von 1082 × 2342 Pixeln (412 × 892 Punkte). Sie wurden vom Programm [captures/captures.mjs] (siehe Beispiel 01) erzeugt, das einen [Chromium]-Browser in dieser Auflösung steuert und für jede Gruppe von Bildschirmen ein Szenario aus dem Ordner [captures/scenarios/] ausführt.

11.3.1. Der Anmeldebildschirm

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

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

Als [admin] angemeldet, gelangen Sie zum Terminkalender. Die Schaltfläche ☰ öffnet das Menü: die für den Administrator zugänglichen Bildschirme und, ganz oben, wer angemeldet ist:

Wählen Sie einen Arzt und ein Datum (das Datum in einem Kalender) und klicken Sie dann auf „Terminkalender anzeigen“. Die URL ändert sich in [/schedule?doctorId=1&day=2026-10-13]. Ein Klick auf „Buchen“ öffnet das Buchungsfenster; die URL ändert sich in [/schedule?doctorId=1&day=2026-10-13&book=2]:

Der Termin wird gespeichert; „Stornieren“ fordert zur Bestätigung auf:

Ein Arzt gelangt direkt zu SEINEM bzw. IHREM Tagesterminkalender:

Image

11.3.3. Der Bereich des Patienten

Ein Patient ([martin]) öffnet „Mein Bereich“. In einem Kalender sieht er bei den Zeitfenstern anderer Patienten „Belegt“ und bucht einen Termin für sich selbst, ohne einen bestimmten Patienten auszuwählen:

Sein Termin erscheint unter seinem Namen; die Schaltfläche „Buchen“ steht nicht mehr zur Verfügung (nur ein bevorstehender Termin). Im Terminkalender eines anderen Arztes, in dem sein Termin nicht erscheint, würde eine Meldung erklären, warum er nicht buchen kann. Sein Bereich zeigt den Termin:

„Mein Konto verwalten“: Jede Änderung erfordert das aktuelle Passwort; die Fehler kommen vom Server:

Image

Das Menü eines Patienten hat keinen Eintrag „Ärzte“. Gibt er im Web die Adresse /doctors selbst ein, zeigt der Guard des Routers eine Fehlerseite 403 an (siehe [app.routes.ts]).

11.3.4. Ärzte und Kunden verwalten

Die Liste der Ärzte; ein falsch ausgefüllter Eintrag:

Ein erfolgreiches Hinzufügen; ein Namensvetter; das Löschen eines Arztes mit Terminen wird abgelehnt:

11.3.5. Ein Konto anlegen

Geben Sie auf dem Anmeldebildschirm das CAPTCHA ein und tippen Sie dann auf „Patientenkonto anlegen“. Das Formular wird vom Server abgelehnt; sobald das Konto angelegt ist, gelangen Sie zum Anmeldebildschirm zurück, wobei die Zugangsdaten bereits ausgefüllt sind:

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

Das Menü FR / EN in der oberen Leiste übersetzt den Bildschirm lokal neu, ohne Anfragen an den Server, einschließlich der Datumsangaben („mardi 13 octobre 2026“). Auf einem breiten Bildschirm (Web, Tablet) bleibt das Menü links angezeigt:

Image

Image

11.3.7. Abgelaufene Sitzung

Läuft der Token ab (oder wird das Cookie gelöscht), erhält die nächste Anfrage eine 401-Antwort; die Anwendung leitet mit einer Meldung zum Anmeldebildschirm um:

Image

11.4. Architektur des Clients

rdvmedecins_ionic/
├── package.json             the packages, the scripts
├── angular.json             the Angular project configuration
├── tsconfig.json            the TypeScript configuration
├── proxy.conf.json          the development server (/api relay)
├── capacitor.config.ts      the Capacitor configuration (Android)
├── android/                 the Android Studio project (after npx cap add android)
├── captures/                the making of the screenshots (Playwright)
├── public/
│   └── i18n/                the dictionaries fr.json, en.json
└── src/
    ├── index.html           the page that hosts the application
    ├── main.ts              the startup
    ├── styles.scss          the common styles
    └── app/
        ├── app.ts           the root component
        ├── back-button.ts   Android's Back button
        ├── app.routes.ts    the screens, their addresses, their access rights
        ├── config.ts        the address of the server
        ├── formatting.ts    the formatting of times and days
        ├── api/             the API access layer
        ├── i18n/            the languages
        ├── state/           session, messages, cache (signal-based services)
        ├── components/      the layout and the reusable components
        └── pages/           the screens

Dies ist die Struktur des [Flutter]-Clients Datei für Datei, mit den Dateinamen von [Angular] (in Kleinbuchstaben, Wörter durch Bindestriche getrennt):

  • eine Datenschicht ([api/]): die einzige, die den HTTP-Client von [Angular], die URLs und das JSON-Format kennt;
  • eine Zustandsschicht ([state/]): signalbasierte Services, per Dependency Injection für die gesamte Anwendung bereitgestellt, die die Bildschirme lesen;
  • eine Oberflächenschicht ([pages/], [components/]): Komponenten, die den Zustand anzeigen und Benutzeraktionen weitergeben.

Die folgende Tabelle vergleicht den [Flutter]-Client mit diesem Client:

Konzept
Flutter-Client
Ionic-Client
Bildschirme
Widgets
Angular- und Ionic-Komponenten
die Elemente rund um die Bildschirme
[layout.dart], das Widget einer [ShellRoute]
[layout.ts], das [ion-router-outlet] umgibt
das Menü
[NavigationDrawer] / [NavigationRail]
[ion-menu] in [ion-split-pane]
die Adressen
[go_router]
der Angular-Router
Zugriffsrechte
die Funktion [redirect] des Routers
Ein Guard: [CanActivateFn]
das Token-Cookie
ein HTTP-Client, der Cookies verwaltet
der Browser (Web), [CapacitorHttp] (Android)
die abgelaufene Sitzung (401)
eine dem [ApiClient] zugewiesene Funktion
ein Interceptor, [HttpInterceptorFn]
der gemeinsame Zustand
[ChangeNotifier] ([provider])
Signal-Services ([inject()])
asynchrone Daten
[FutureBuilder]
[resource()]
bereits gelesene Daten
[Cache] (einige Zeilen)
[Cache] (einige Zeilen)
die gespeicherte Sprache
[shared_preferences]
[@capacitor/preferences]
abgelehntes Formular
Fehler unter den Feldern
ebenso

Alle Dateien des Clients sind unten aufgeführt. Sie sind ausführlich kommentiert; diese Kommentare sind Teil des Kursmaterials.

11.5. Projektkonfiguration

Das Projekt wurde auf dieselbe Weise erstellt wie die Beispiele (siehe Beispiel 01): [ng new], gefolgt vom Hinzufügen der Pakete [Ionic] und [Capacitor]. Die Dateien [angular.json] und [tsconfig.json] sind die von [ng new] erzeugten; sie sind mit denen der Beispiele identisch, mit zwei Ausnahmen: in [angular.json]der Port des Entwicklungsservers (8100) und die Weiterleitungsdatei ([proxyConfig]); in [tsconfig.json]die strikten Prüfungen ([strict], [strictTemplates]).

11.5.1. package.json

{
  "name": "rdvmedecins-ionic",
  "version": "0.0.0",
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
    "build": "ng build",
    "watch": "ng build --watch --configuration development",
    "android": "ng build && cap sync android && cap run android",
    "captures": "node captures/captures.mjs"
  },
  "private": true,
  "packageManager": "npm@10.9.4",
  "dependencies": {
    "@angular/common": "^22.2.0",
    "@angular/compiler": "^22.2.0",
    "@angular/core": "^22.2.0",
    "@angular/forms": "^22.2.0",
    "@angular/platform-browser": "^22.2.0",
    "@angular/router": "^22.2.0",
    "@capacitor/android": "^8.5.2",
    "@capacitor/app": "^8.1.2",
    "@capacitor/core": "^8.5.2",
    "@capacitor/preferences": "^8.0.1",
    "@ionic/angular": "^9.0.6",
    "ionicons": "^8.1.0",
    "rxjs": "~7.8.0",
    "tslib": "^2.3.0"
  },
  "devDependencies": {
    "@angular/build": "^22.2.1",
    "@angular/cli": "^22.2.1",
    "@angular/compiler-cli": "^22.2.0",
    "@capacitor/cli": "^8.5.2",
    "playwright": "^1.56.1",
    "prettier": "^3.8.1",
    "typescript": "~6.0.2"
  }
}
  • Zeilen 4–11: die Skripte: [npm start] startet den Entwicklungsserver, [npm run build] kompiliert die Anwendung, [npm run android] kompiliert sie, kopiert sie in das [Android]-Projekt und führt sie auf dem Smartphone aus; [npm run captures] erzeugt die Screenshots;
  • Zeilen 14–29: die Pakete der Anwendung: [Angular] (ohne [@angular/animations] oder [zone.js]: Die Anwendung ist „zoneless“, siehe Beispiel 01), [Capacitor] (sein Kern, die Plattform [Android], das Plugin [App], das den Zugriff auf die Zurück-Taste bietet, und das Plugin [Preferences], das die Sprache speichert), [Ionic] und seine Icons; [rxjs] ist die Bibliothek für die [Observable]s des HTTP-Clients;
  • Zeilen 30–38: Entwicklungswerkzeuge: der [Angular]-Compiler, der Befehl [ng], der Befehl [cap] von [Capacitor], [Playwright] für die Screenshots, [Prettier] für die Code-Formatierung, [TypeScript].

Es gibt KEINE zusätzlichen Pakete gegenüber den Beispielen: keine Bibliotheken für Übersetzung, Zustandsverwaltung oder Formulare. Alles, was die Anwendung braucht, steckt in [Angular] und [Ionic] und in einigen hier geschriebenen Dateien.

11.5.2. proxy.conf.json

1
2
3
4
5
6
7
8
{
  "/api": {
    "target": "http://localhost:8080",
    "secure": false,
    "changeOrigin": false,
    "logLevel": "warn"
  }
}

Die aus Beispiel 22: In der Webentwicklung leitet [ng serve] die /api-Anfragen an den JSON-Server weiter. Für den Browser haben die Anwendung und die API denselben Origin (http://localhost:8100): keine CORS-Authentifizierung, und das Token-Cookie wird mitgesendet.

11.5.3. capacitor.config.ts

// =========================================================================
// capacitor.config.ts - die Konfiguration von Capacitor
// -------------------------------------------------------------------------
// Capacitor macht aus der Webanwendung (dem von ng build erzeugten Ordner)
// eine Android-Anwendung: Es verpackt sie in ein Android-Studio-Projekt
// (Ordner android/), in dem sie von einer "WebView" angezeigt wird, der Engine des
// Chrome-Browsers des Telefons. Befehle (siehe das Kapitel Bereitstellung):
//     npx cap add android       (nur einmal: erstellt den Ordner android/)
//     ng build                  (erstellt die Webanwendung)
//     npx cap sync android      (kopiert sie in das Android-Projekt)
//     npx cap run android       (führt sie auf einem Emulator oder Telefon aus)
// =========================================================================

import type { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  // die eindeutige Kennung der Anwendung auf dem Telefon (und im Play Store)
  appId: 'fr.stahe.rdvmedecins',
  // der unter dem Symbol angezeigte Name
  appName: 'RdvMedecins',
  // der Ordner der kompilierten Webanwendung (ng build)
  webDir: 'dist/rdvmedecins_ionic/browser',
  server: {
    // erlaubt unverschlüsselte HTTP-Anfragen (http://10.0.2.2:8080) an
    // den JSON-Entwicklungsserver (in der Produktion zu entfernen: HTTPS)
    cleartext: true,
  },
  plugins: {
    // CapacitorHttp: Die HTTP-Anfragen der Anwendung werden nicht mehr
    // von der WebView gestellt, sondern vom nativen Code von Android. Folgen (siehe
    // api/http-client.ts): keine CORS-Prüfung (der JSON-Server muss nichts
    // erlauben), und die Cookies (das des Authentifizierungs-Tokens) werden
    // von Android gespeichert und automatisch zurückgesendet
    CapacitorHttp: {
      enabled: true,
    },
  },
};

export default config;

Die Konfiguration von [Capacitor] (siehe Beispiel 01):

  • Zeile 18: die Anwendungs-ID auf dem Smartphone (und im [Play Store]): die der [Flutter]-Anwendung. Daher können beide nicht gleichzeitig auf demselben Smartphone installiert werden; um sie zu vergleichen, müsste eine der beiden geändert werden;
  • Zeile 22: der Ordner der kompilierten Webanwendung, den [npx cap sync] in das [Android]-Projekt kopiert;
  • Zeile 26: Standardmäßig lehnt [Android] unverschlüsselte HTTP-Anfragen ab; sie werden erlaubt, um sich mit dem Entwicklungsserver zu verbinden ([http://10.0.2.2:8080]). In der Produktion muss der Server auf HTTPS eingestellt sein;
  • Zeilen 34–36: das [CapacitorHttp]-Plugin (Beispiel 22): Auf dem Smartphone werden HTTP-Anfragen nicht mehr von der [WebView] gestellt, sondern vom nativen Code von [Android]. Der Server muss daher keine CORS-Regeln beachten, und Cookies werden von [Android] selbst gespeichert und zurückgesendet. Dadurch kann der [Ionic]-Client auf den HTTP-Client verzichten, der für den [Flutter]-Client Cookies „verwaltet“.

11.6. Start der Anwendung

11.6.1. src/app/config.ts

// =========================================================================
// src/app/config.ts - WO liegt der JSON-Server?
// -------------------------------------------------------------------------
// Die Frage stellt sich nicht für eine Webanwendung, die vom
// Server selbst ausgeliefert wird: Die Anfragen gehen an denselben Ursprung wie die Seite
// (eine relative Adresse, /api/...). Eine MOBILE Anwendung hat aber keinen
// verwendbaren Ursprung (unter Android wird die Seite von Capacitor
// über https://localhost ausgeliefert): Ihr muss die vollständige Adresse des Servers mitgegeben werden.
//   - Der Android-Emulator sieht den Rechner, auf dem er läuft, unter
//     der Adresse 10.0.2.2 (localhost ist für ihn der Emulator selbst);
//   - ein echtes Telefon, das mit demselben WLAN wie der Rechner verbunden ist, muss
//     die Adresse des Rechners in diesem Netz verwenden (192.168.1.20 ...):
//     Sie wird beim Erstellen der Anwendung angegeben:
//         ng build --define "SERVER='http://192.168.1.20:8080'"
//   - In der Webentwicklung (ng serve) leitet der Entwicklungsserver
//     von Angular die /api-Anfragen an den JSON-Server weiter (Datei
//     proxy.conf.json): Eine relative Adresse genügt.
// =========================================================================

import { Capacitor } from '@capacitor/core';

// der Wert, der beim Erstellen mit --define "SERVER='...'" angegeben wird
// (ng build, ng serve). Die Option ersetzt im kompilierten Code das Wort
// SERVER durch den angegebenen Wert. Ohne sie existiert SERVER nicht: typeof
// erlaubt es uns, dies ohne Fehler zu prüfen
declare const SERVER: string | undefined;
const forcedServer = typeof SERVER === 'string' ? SERVER : '';

export const config = {
  // Capacitor.isNativePlatform(): true in der Android-Anwendung (oder iOS),
  // false in einem Browser; Capacitor.getPlatform(): 'android', 'ios' oder 'web'
  serverUrl:
    forcedServer !== ''
      ? forcedServer
      : !Capacitor.isNativePlatform()
        ? '' // das Web: derselbe Ursprung, relative Adressen
        : Capacitor.getPlatform() === 'android'
          ? 'http://10.0.2.2:8080'
          : 'http://localhost:8080',
};

Die Serveradresse in Abhängigkeit von der Plattform (siehe Beispiel 22):

  • Zeile 26: [declare const SERVER] deklariert dem [TypeScript] -Compiler eine Konstante, die er sonst nirgends sieht; sie wird vom Kompilierbefehl bereitgestellt ([ng build --define "SERVER='...'"]). Die Option [--define] ERSETZT im kompilierten Code das Wort [SERVER] durch den angegebenen Wert: Die Adresse wird in die erstellte Anwendung geschrieben, genau wie bei [--dart-define] von [Flutter];
  • Zeile 27: Ohne diese Option existiert [SERVER] nicht, und der Versuch, es zu lesen, würde einen Laufzeitfehler auslösen; [typeof] ist der einzige Operator, der einen unbekannten Namen akzeptiert (er liefert dann „undefined“);
  • Zeilen 32–39: Andernfalls eine relative Webadresse (der Entwicklungsserver, in der Produktion der JSON-Server selbst, liefern die Seite UND die API aus), [10.0.2.2] unter [Android] (der Computer, vom Emulator aus gesehen), [localhost] anderswo. [Capacitor.isNativePlatform()] gibt an, ob die Anwendung in der nativen Umgebung von [Capacitor] läuft (und nicht in einem Browser), und [Capacitor.getPlatform()] nennt das jeweilige System.

11.6.2. src/main.ts

// =========================================================================
// src/main.ts - der Einstiegspunkt der Anwendung
// -------------------------------------------------------------------------
// Eine Angular-Anwendung startet mit bootstrapApplication: Angular erzeugt
// die ROOT-Komponente (App) und fügt sie in das Tag <app-root> der
// Seite index.html ein. Der zweite Parameter liefert die "Provider"
// der gesamten Anwendung: Ionic, den Router, den HTTP-Client und seinen
// Interceptor, den Titel der Bildschirme und das Laden der Sprache.
// Die Services (Sitzung, Meldungen, Cache, Übersetzungen, API) müssen hier nicht
// deklariert werden: providedIn: 'root' stellt sie der gesamten Anwendung bereit.
// =========================================================================

import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { inject, provideAppInitializer } from '@angular/core';
import { bootstrapApplication } from '@angular/platform-browser';
import { provideRouter, TitleStrategy, withComponentInputBinding } from '@angular/router';
import { provideIonicAngular } from '@ionic/angular';
import { apiInterceptor } from './app/api/http-client';
import { App } from './app/app';
import { routes } from './app/app.routes';
import { PageTitle } from './app/components/page-title';
import { Translations } from './app/i18n/translations';

bootstrapApplication(App, {
  providers: [
    // Ionic: Modus 'md' (Material Design) = das Aussehen von Android, selbst im
    // Browser eines Computers
    provideIonicAngular({ mode: 'md' }),
    // der Router: die Liste der Routen (app.routes.ts);
    // withComponentInputBinding: Die Parameter einer Route (:id, ?day=...,
    // data) werden an die Inputs der Komponente des Bildschirms übergeben
    provideRouter(routes, withComponentInputBinding()),
    // der HTTP-Client von Angular, dessen jede Anfrage durch unseren Interceptor läuft
    provideHttpClient(withInterceptors([apiInterceptor])),
    // unsere Bildschirmtitel sind Übersetzungsschlüssel (siehe page-title.ts)
    { provide: TitleStrategy, useClass: PageTitle },
    // vor dem ersten Bildschirm: die Sprache (gespeichert oder die des Geräts)
    // und ihr Wörterbuch. Angular wartet auf das Ende des zurückgegebenen Promise
    provideAppInitializer(() => inject(Translations).start()),
  ],
}).catch((err) => console.error(err));

Start. Hier gibt es nur Provider: Die gemeinsamen Objekte (die Sitzung, die Meldungen, der Cache, die Übersetzungen und die API-Zugriffsschicht) sind [providedIn: 'root']-Services, die von [Angular] bei ihrer ersten Injektion erzeugt werden (siehe Beispiel 14).

  • Zeile 28: [Ionic] im Modus [md] (das Erscheinungsbild von [Android]);
  • Zeile 32: der Router; [withComponentInputBinding()] stellt die Adressparameter ([?day=...], [:id]) und die Routendaten ([data]) den Inputs der Bildschirmkomponenten bereit (siehe Beispiel 17). So müssen die Bildschirme die Adresse nie selbst lesen;
  • Zeile 34: der HTTP-Client und sein Interceptor (siehe [api/http-client.ts]);
  • Zeile 36: Die „Title Strategy“ des Routers wird durch unsere ersetzt, die die Titel übersetzt (siehe [components/page-title.ts]);
  • Zeile 39: [provideAppInitializer]: eine Funktion, die ausgeführt wird, BEVOR der erste Bildschirm angezeigt wird; gibt sie ein [Promise] zurück, wartet [Angular] auf dessen Abschluss. Hier wird das Wörterbuch der Ausgangssprache geladen: Der erste Bildschirm erscheint direkt in der richtigen Sprache (das entspricht dem [await translations.start()] vor [runApp] im [Flutter]-Client).

11.6.3. src/app/app.ts

// =========================================================================
// src/app/app.ts - die ROOT-Komponente der Anwendung
// -------------------------------------------------------------------------
// Es zeigt das Layout an (das den Platz der Bildschirme enthält) und verbindet
// die Services der Anwendung über zwei Mechanismen:
//   1. Die Sitzung ändert sich (Anmeldung, Abmeldung, abgelaufene Sitzung): Die
//      für den vorherigen Benutzer gelesenen Daten sind wertlos (der Cache wird
//      geleert), und die Router-Guards werden für
//      den aktuellen Bildschirm neu ausgewertet: Sie sind es, die den Anmeldebildschirm nach
//      der Anmeldung verlassen oder nach einer Abmeldung wieder dorthin zurückschicken;
//   2. die "Flash"-Meldungen: Am Ende JEDER Navigation verschwinden die Meldungen
//      des vorherigen Bildschirms, die für den nächsten
//      Bildschirm hinterlassenen erscheinen (siehe state/messages.ts).
// Die ABGELAUFENE Sitzung (Antwort 401) wird vom Interceptor behandelt
// (api/http-client.ts): Er leert die Sitzung, und Mechanismus 1 erledigt den Rest.
// Es bindet auch die Zurück-Taste von Android ein (siehe back-button.ts).
// =========================================================================

import { Component, computed, effect, inject, untracked } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router } from '@angular/router';
import { IonApp, NavController } from '@ionic/angular';
import { filter } from 'rxjs';
import { handleBackButton } from './back-button';
import { Layout } from './components/layout';
import { Cache } from './state/cache';
import { Messages } from './state/messages';
import { Session } from './state/session';

@Component({
  selector: 'app-root',
  imports: [IonApp, Layout],
  template: `
    <ion-app>
      <app-layout />
    </ion-app>
  `,
})
export class App {
  private readonly session = inject(Session);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  private readonly navigation = inject(NavController);
  // die Rolle des angemeldeten Benutzers (null: niemand). Ein neuer Name
  // (Kontoaktualisierung) ändert dieses Signal nicht: Nur Anmeldung
  // und Abmeldung ändern es
  private readonly role = computed(() => this.session.user()?.role ?? null);
  private url = '';

  constructor() {
    // die Zurück-Taste von Android
    handleBackButton();
    // 1a. die Sitzung ändert sich: Der Cache wird geleert
    effect(() => {
      this.session.user();
      untracked(() => this.cache.clear());
    });
    // 1b. Anmeldung, Abmeldung: Die Guards werden für die aktuelle
    // Adresse neu ausgewertet. navigateRoot: Der angezeigte Bildschirm ersetzt den gesamten
    // Stapel der Bildschirme von Ionic (die des vorherigen Benutzers verschwinden);
    // onSameUrlNavigation: 'reload': Auch zur aktuellen Adresse findet die
    // Navigation statt (und die Guards laufen)
    effect(() => {
      this.role();
      untracked(() => {
        // nicht vor der ersten Navigation: Sie kümmert sich selbst darum
        if (!this.router.navigated) return;
        void this.navigation.navigateRoot(this.router.url, { onSameUrlNavigation: 'reload', replaceUrl: true });
      });
    });
    // 2. bei jeder abgeschlossenen Navigation (die Adresse hat sich geändert): neue Seite
    this.router.events
      .pipe(
        filter((e) => e instanceof NavigationEnd),
        takeUntilDestroyed(),
      )
      .subscribe((e) => {
        if (e.urlAfterRedirects !== this.url) {
          this.url = e.urlAfterRedirects;
          this.messages.newPage();
        }
      });
  }
}

Die Wurzelkomponente: Sie zeigt das Layout an und verbindet die Services der Anwendung miteinander, genau wie es [main.dart] tat:

  • Zeilen 34–36: [ion-app], der Container der gesamten [Ionic]-Anwendung, und das Layout (siehe [components/layout.ts]), das die Plätze für die Bildschirme enthält;
  • Zeile 48: die Rolle des angemeldeten Benutzers, aus der Sitzung berechnet. Ein berechnetes Signal ([computed]) benachrichtigt seine Leser nur, wenn sich sein WERT ändert: Eine Änderung seines Namens („Mein Konto verwalten“) ändert den Benutzer, aber nicht seine Rolle;
  • Zeile 53: die Zurück-Taste für [Android], verbunden durch die Funktion aus [back-button.ts] (unten);
  • Zeilen 55–58: 1a. Bei jedem Benutzerwechsel wird der Cache geleert: Die für den vorigen Benutzer gelesenen Daten sind für den nächsten ohne Belang (ein Patient soll nicht den Terminkalender sehen, den der Administrator angesehen hat). Ein Effekt ([effect]) wird erneut ausgeführt, wenn sich ein von ihm gelesenes Signal ändert: hier [this.session.user()]. [untracked]: Was danach geschieht, ist keine Abhängigkeit des Effekts;
  • Zeilen 64–71: 1b. Bei jeder An- oder Abmeldung „navigiert“ das System erneut zur aktuellen Adresse, wodurch die Guards des Routers erneut ausgeführt werden (siehe [app.routes.ts]): Der Guard verlässt den Anmeldebildschirm nach einer erfolgreichen Anmeldung oder kehrt nach einer Abmeldung oder einer abgelaufenen Sitzung zu ihm zurück. Das ist das [refreshListenable] von [go_router], von Hand nachgebaut. [navigateRoot] (aus dem [NavController] von [Ionic]): Der angezeigte Bildschirm ersetzt den GANZEN Bildschirmstapel von [Ionic]; die Bildschirme des vorigen Benutzers werden zerstört. [onSameUrlNavigation: 'reload']: Ohne diese Option ignoriert der Router die Navigation zur aktuellen Adresse;
  • Zeile 68: Beim Start läuft der Effekt vor der ersten Navigation, die die Prüfungen ohnehin ausführen wird: Es geschieht nichts;
  • Zeilen 73–83: 2. Flash-Meldungen. Der Router veröffentlicht seine Ereignisse in einem [Observable] ([router.events]); nur die Ereignisse am Ende einer Navigation werden beibehalten ([filter]), und wenn sich die Adresse geändert hat, wechselt das System zu einer „neuen Seite“: Die Meldungen des vorigen Bildschirms verschwinden, und die für diesen vorgemerkten erscheinen (siehe [messages.ts]). Die Zurück-Taste, die das Buchungsfenster schließt, ändert die URL: Sie löscht daher ebenfalls die Meldungen. [takeUntilDestroyed()]: Das Abonnement endet mit der Komponente (hier mit der Anwendung).

11.6.4. src/app/back-button.ts

// =========================================================================
// src/app/back-button.ts - die Zurück-Taste von Android
// -------------------------------------------------------------------------
// Auf dem Telefon empfängt Capacitor das Drücken der Zurück-Taste. Hat es
// keinen Listener für dieses Ereignis, geht es nur im Verlauf der
// WebView zurück und schließt dann die Anwendung: Ionic weiß nichts
// davon (ein offener Dialog schließt sich nicht, das Drawer-Menü auch nicht).
// Das Plugin @capacitor/app lässt uns es abonnieren: Sobald es einen
// Listener gibt, leitet Capacitor das Drücken an Ionic weiter, das den Handler mit
// der höchsten Priorität aufruft:
//   - 100: Ein offener Dialog (Alert, ion-modal ...) schließt sich;
//   -  99: Das offene Drawer-Menü schließt sich;
//   -   1: (unser Handler) Wir gehen zum vorherigen Bildschirm zurück; gibt es keinen,
//          beenden wir die Anwendung.
// Im Browser gibt es keine Zurück-Taste: Wir tun nichts.
// =========================================================================

import { inject } from '@angular/core';
import { NavController, Platform } from '@ionic/angular';
import { App as CapacitorApp } from '@capacitor/app';
import { Capacitor } from '@capacitor/core';

// im Konstruktor der Root-Komponente aufzurufen (Injektionskontext)
export function handleBackButton(): void {
  if (!Capacitor.isNativePlatform()) return;
  const navigation = inject(NavController);
  // ein (leerer) Listener: Capacitor leitet das Drücken nun an Ionic weiter
  void CapacitorApp.addListener('backButton', () => {});
  inject(Platform).backButton.subscribeWithPriority(1, async () => {
    // pop(): zurück zum vorherigen Bildschirm des Stacks von Ionic; false: der
    // Stack enthält nur den angezeigten Bildschirm, dahinter ist nichts mehr
    if (!(await navigation.pop())) {
      await CapacitorApp.exitApp();
    }
  });
}

Dieselbe Datei wie in den Beispielen (siehe Beispiel 01, „Die Zurück-Taste von Android“). Sie weist hier der Zurück-Taste des Smartphones nacheinander folgende Funktionen zu: ein geöffnetes Fenster schließen (das Buchungsfenster, eine Bestätigungsabfrage, die Liste der Ärzte, den Kalender), das Seitenmenü schließen, zum vorigen Bildschirm zurückkehren und schließlich die App vom ersten Bildschirm aus beenden.

11.6.5. src/styles.scss

// =========================================================================
// src/styles.scss - die Stile der gesamten Anwendung
// -------------------------------------------------------------------------
// Die Stylesheets von Ionic: Ohne sie haben seine Komponenten nicht
// ihr Aussehen. core.css ist unverzichtbar; die anderen sind Hilfsmittel
// (Abstände, Ausrichtungen, Klassen ion-padding, ion-text-center ...).
// =========================================================================

@use '@ionic/angular/css/core.css';
@use '@ionic/angular/css/normalize.css';
@use '@ionic/angular/css/structure.css';
@use '@ionic/angular/css/typography.css';
@use '@ionic/angular/css/padding.css';
@use '@ionic/angular/css/float-elements.css';
@use '@ionic/angular/css/text-alignment.css';
@use '@ionic/angular/css/text-transformation.css';
@use '@ionic/angular/css/flex-utils.css';
@use '@ionic/angular/css/display.css';

// die Hauptfarbe der Anwendung (Schaltflächen, obere Leiste): ein Indigo,
// wie in den Beispielen des Kurses. Ionic leitet aus --ion-color-primary die
// hellere (tint) und die dunklere (shade) Variante ab
:root {
  --ion-color-primary: #3f51b5;
  --ion-color-primary-rgb: 63, 81, 181;
  --ion-color-primary-contrast: #ffffff;
  --ion-color-primary-contrast-rgb: 255, 255, 255;
  --ion-color-primary-shade: #37479f;
  --ion-color-primary-tint: #5262bc;
}

// -------------------------------------------------------------------------
// die für die Bildschirme von RdvMedecins gemeinsamen Stile
// -------------------------------------------------------------------------

// der Titel eines Bildschirms
h1 {
  font-size: 26px;
  font-weight: 400;
  margin: 8px 0 12px;
}

// der Titel eines Abschnitts ("Benutzerkonto")
h3 {
  font-size: 15px;
  font-weight: 500;
  margin: 16px 0 12px;
}

// ein Hilfetext, in Grau
.help,
.intro {
  font-size: 14px;
  color: var(--ion-color-medium-shade);
}

// ein kleiner Abstand unter jeder Dropdown-Liste
ion-select {
  margin-bottom: 12px;
}

// die Schaltflächen eines Formulars, nebeneinander (untereinander, wenn sie
// nicht passen)
.buttons {
  display: flex;
  flex-wrap: wrap;
  gap: 8px;
  margin-top: 12px;
}

// die Demo-Konten des Anmeldebildschirms
.demo {
  margin-top: 16px;
  font-size: 13px;
  color: var(--ion-color-medium-shade);

  code {
    font-family: 'Roboto Mono', monospace;
    font-size: 12px;
  }
}

// das Bestätigungsfenster (AlertController, siehe confirmation.ts): etwas
// breiter, und seine Schaltfläche "Ja" in Rot
ion-alert.confirmation {
  --min-width: 310px;
  --max-width: 340px;
}

ion-alert.confirmation button.danger-button {
  background: #d32f2f;
  color: white;
  border-radius: 20px;
  padding: 0 16px;
}

// ein Dialog (ion-modal) in der Größe seines Inhalts, in der Mitte des Bildschirms,
// statt über den ganzen Bildschirm (Standard auf einem Telefon)
ion-modal.dialog {
  --width: calc(100% - 48px);
  --max-width: 420px;
  --height: fit-content;
  --border-radius: 16px;
}

Für alle Bildschirme gemeinsame Stile:

  • Zeilen 9–18: die Stylesheets von [Ionic] (siehe Beispiel 01);
  • Zeilen 23–30: die Hauptfarbe Indigo und ihre Varianten;
  • Zeilen 37–60: Titel, Hilfetexte und der Abstand unter den Dropdown-Listen;
  • Zeilen 64–69: die Schaltflächen der Formulare, nebeneinander oder untereinander, wenn sie nicht passen ([Wrap] von [Flutter], in CSS: [flex-wrap: wrap]);
  • Zeilen 72–81: die Demo-Konten auf dem Anmeldebildschirm, klein gedruckt; die Benutzernamen in einer Festbreitenschrift;
  • Zeilen 85–95: das Bestätigungsfeld, etwas breiter als das von [Ionic] („Nein, zurück“ und „Ja, bestätigen“ passen in eine Zeile), und seine rote Schaltfläche. Die von [AlertController] erzeugten Felder werden am Ende der Seite eingefügt, außerhalb jeder Komponente: Nur ein globales Stylesheet kann sie beeinflussen;
  • Zeilen 99–104: Ein Fenster ([ion-modal]) der Klasse [dialog] nimmt die Größe seines Inhalts an und wird auf dem Bildschirm zentriert. Auf einem Smartphone nimmt ein [Ionic]-Fenster standardmäßig den ganzen Bildschirm ein; das Buchungs- und das Kalenderfenster ähneln so den Dialogfeldern von [Material]. [fit-content]: die Höhe des Inhalts.

11.7. Die API-Zugriffsschicht

11.7.1. src/app/api/api-client.ts

// =========================================================================
// src/app/api/api-client.ts - ALLE Anfragen an die API laufen hier durch
// -------------------------------------------------------------------------
// Übernommen aus der API-Schicht der Beispiele (Beispiel 24): eine einzige Methode,
// request(), die die vollständige Adresse erstellt (config.serverUrl + /api +
// url), den Body als JSON sendet und ein Promise der Antwort zurückgibt.
//
// Der HTTP-Client von Angular (HttpClient) leitet jede Anfrage durch den
// INTERCEPTOR der Anwendung (http-client.ts), der jeden
// Fehler in einen ApiError umwandelt und an EINER einzigen Stelle die Antwort 401
// (Sitzung abgelaufen) behandelt.
// Einige Anfragen behandeln ihre 401 selbst (die Anmeldung, GET
// /api/auth/me ...): Sie sind "öffentlich"; dies wird dem
// Interceptor über den KONTEXT der Anfrage (HttpContext) signalisiert.
// =========================================================================

import { HttpClient, HttpContext, HttpContextToken } from '@angular/common/http';
import { inject, Injectable } from '@angular/core';
import { firstValueFrom } from 'rxjs';
import { config } from '../config';

// eine an eine Anfrage angehängte Information, die der Interceptor liest. Ihr
// Standardwert (false): eine geschützte Anfrage
export const PUBLIC = new HttpContextToken<boolean>(() => false);

export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';

@Injectable({ providedIn: 'root' })
export class ApiClient {
  private readonly http = inject(HttpClient);

  // isPublic: true für die Routen, die die 401 selbst behandeln.
  // Bei einem Fehlschlag wird das Promise mit einem ApiError zurückgewiesen
  request<T>(method: Method, url: string, body?: unknown, isPublic = false): Promise<T> {
    // http.request liefert ein Observable; firstValueFrom wandelt es in ein
    // Promise um (die Anfrage wird in diesem Moment gesendet). Das Body-Objekt wird
    // als JSON gesendet (Header content-type: application/json), die JSON-Antwort wird
    // dekodiert (null, wenn ihr Body leer ist)
    return firstValueFrom(
      this.http.request<T>(method, `${config.serverUrl}/api${url}`, {
        body,
        context: new HttpContext().set(PUBLIC, isPublic),
      }),
    );
  }
}

Alle Anfragen laufen über die Methode [request] (siehe Beispiel 24):

  • Zeile 24: ein „Kontext-Token“ – eine an eine Anfrage angehängte Information, die der Interceptor lesen kann. Sein Standardwert wird von der Funktion geliefert: [false], eine geschützte Anfrage;
  • Zeile 34: eine generische Methode: [request<Person[]>(...)] liefert ein [Promise<Person[]>]. [isPublic = false]: ein optionaler Parameter mit seinem Standardwert;
  • Zeilen 39–44: [http.request] liefert ein [Observable] (Beispiel 22), das die Anfrage erst sendet, wenn es abonniert wird; [firstValueFrom] abonniert es und liefert ein [Promise] mit seinem ersten Wert (der Antwort). Der Body ist ein [JavaScript]-Objekt: Der HTTP-Client sendet es als JSON, mit dem passenden [Content-Type]-Header; das JSON der Antwort wird dekodiert (als UTF-8: Die Akzente bleiben erhalten). Der Kontext der Anfrage trägt die Information „öffentlich“.

Der [Flutter] -Client behandelte hier die Fehler und den Statuscode 401; der [Ionic] -Client delegiert sie an den Interceptor.

11.7.2. src/app/api/http-client.ts

// =========================================================================
// src/app/api/http-client.ts - der INTERCEPTOR der HTTP-Anfragen
// -------------------------------------------------------------------------
// Ein Interceptor ist eine Funktion, durch die JEDE Anfrage des HTTP-Clients
// von Angular läuft (er wird in main.ts deklariert:
// provideHttpClient(withInterceptors([apiInterceptor]))). Er erhält die
// Anfrage und den Handler "next", der sie sendet; er kann Erstere ändern und die
// Antwort umwandeln. Unserer behandelt die FEHLER:
//   - jeder Fehler wird zu einem ApiError (siehe api-error.ts);
//   - die Antwort 401 einer geschützten Anfrage (Sitzung abgelaufen) wird
//     HIER ein für alle Mal behandelt: Der Benutzer wird vergessen, der Cache
//     geleert, die Meldung für den Anmeldebildschirm vorbereitet. Die
//     Router-Guards, die bei einer Änderung der Sitzung neu ausgewertet werden (siehe app.ts), schicken dann
//     zum Anmeldebildschirm zurück.
//
// Und das COOKIE des JWT-Tokens? Der Server legt ihn in ein Cookie
// (httpOnly). Der Code der Anwendung hat NICHTS damit zu tun:
//   - im Web speichert der Browser das Cookie und sendet es zurück;
//   - unter Android sendet das Plugin CapacitorHttp (aktiviert in
//     capacitor.config.ts) die Anfragen über den nativen Code
//     von Android, der die Cookies speichert und ebenfalls zurücksendet (und
//     sie behält, wenn die Anwendung beendet und neu gestartet wird).
// =========================================================================

import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { catchError, throwError } from 'rxjs';
import { Cache } from '../state/cache';
import { Messages } from '../state/messages';
import { Session } from '../state/session';
import { PUBLIC } from './api-client';
import { ApiError } from './api-error';

export const apiInterceptor: HttpInterceptorFn = (request, next) => {
  // inject(): nur hier, am Anfang der Funktion (später, in
  // catchError, befinden wir uns nicht mehr in einem "Injektionskontext")
  const session = inject(Session);
  const cache = inject(Cache);
  const messages = inject(Messages);
  const isPublic = request.context.get(PUBLIC);

  // next(request): Die Anfrage wird gesendet; pipe(catchError(...)): was zu
  // tun ist, wenn sie scheitert (die erfolgreiche Antwort läuft unverändert durch)
  return next(request).pipe(
    catchError((e: unknown) => {
      // ein Fehler, der nicht vom HTTP-Client stammt: eine Anomalie, durchlassen
      if (!(e instanceof HttpErrorResponse)) return throwError(() => e);
      const error = ApiError.fromResponse(e);
      if (error.statusCode === 401 && !isPublic) {
        session.forget();
        cache.clear();
        messages.flash({ success: false, key: 'ERRORS.SESSION_EXPIRED' });
        // der Bildschirm, der auf die Antwort wartet, zeigt AUCH diese Meldung an
        return throwError(() => new ApiError(401, 'ERRORS.SESSION_EXPIRED'));
      }
      return throwError(() => error);
    }),
  );
};

Der Interceptor für Anfragen: Er behandelt an EINER einzigen Stelle alle Fehler und insbesondere die 401-Antwort.

  • Zeile 34: Ein Interceptor ist eine einfache Funktion ([HttpInterceptorFn]), die in [main.ts] deklariert wird: Sie erhält die Anfrage und die Funktion [next], die sie weiterleitet (an den Server oder, falls es mehrere gibt, an den nächsten Interceptor), und liefert das [Observable] der Antwort zurück;
  • Zeilen 37–39: die vom Interceptor benötigten Services. [inject()] ist nur am Anfang der Funktion erlaubt, im „Injektionskontext“, in dem [Angular] sie aufruft: Später, in [catchError], existiert dieser Kontext nicht mehr;
  • Zeile 40: Ist die Anfrage öffentlich? (siehe [api-client.ts]);
  • Zeilen 44–58: [next(request)] sendet die Anfrage; [pipe(catchError(...))] verarbeitet das [Observable] der Antwort: Eine erfolgreiche Antwort läuft unverändert hindurch; ein Fehler wird von der angegebenen Funktion verarbeitet, die ein neues [Observable] zurückgibt (hier wieder einen Fehler: [throwError]);
  • Zeile 47: Ein Fehler, der nicht von einer HTTP-Antwort stammt, ist eine Anomalie des Clients: Er wird unverändert weitergereicht;
  • Zeile 48: Jede Fehlerantwort wird zu einem [ApiError] (siehe [api-error.ts]);
  • Zeilen 49–55: Eine 401 bei einer geschützten Anfrage bedeutet, dass die Sitzung abgelaufen ist: Der Benutzer wird vergessen, der Cache geleert und die Meldung für den nächsten Bildschirm vorbereitet. Den Bildschirmwechsel übernehmen jedoch die Guards des Routers, die bei einer Änderung der Sitzung neu ausgewertet werden (siehe [app.ts]). Es wird trotzdem ein Fehler zurückgegeben (der Bildschirm, der auf die Antwort wartete, muss erfahren, dass sie nicht eingetroffen ist), mit dem Schlüssel [ERRORS.SESSION_EXPIRED]: Zeigt dieser Bildschirm den Fehler an, ist es dieselbe Meldung.

Und das Token-Cookie? Der Client muss NICHTS schreiben: Im Web speichert der Browser es und sendet es zurück; unter [Android] leitet [CapacitorHttp] die Anfragen über den nativen Code, der es ebenfalls speichert und erneut sendet und es auch behält, wenn die Anwendung beendet und neu gestartet wird (siehe Beispiel 23). Das ist die wichtigste Vereinfachung gegenüber dem [Flutter]-Client, der den [Set-Cookie]-Header selbst lesen und den [Cookie]-Header selbst schreiben musste.

11.7.3. src/app/api/api-error.ts

// =========================================================================
// src/app/api/api-error.ts - EINE Klasse für alle API-Fehler
// -------------------------------------------------------------------------
// Alle Fehlerantworten des RdvMedecins-Servers haben dieselbe Form:
//   { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Eine Anfrage kann aber auch ANDERS scheitern: gar keine Antwort
// (Netz ausgefallen, Server gestoppt, falsche Adresse) oder eine Antwort, die nicht
// von unserem Server stammt (eine Fehlerseite eines Proxys). Wir wandeln
// all dies in EINE Klasse um, ApiError, die den vom Server gesendeten
// Übersetzungsschlüssel trägt (und, falls vorhanden, seine Parameter und den Fehler
// jedes Felds).
// =========================================================================

import { HttpErrorResponse } from '@angular/common/http';

// ein Objekt { name: Text }
export type Texts = Record<string, string>;

// "extends Error": ein vollwertiger JavaScript-Fehler (throw, catch, und
// die Eigenschaft error() einer Angular-Resource behält ihn unverändert)
export class ApiError extends Error {
  constructor(
    readonly statusCode: number, // 0: Der Server hat nicht geantwortet
    readonly key: string, // z. B. 'ERRORS.LOGIN_TAKEN'
    readonly params: Texts = {},
    readonly fields: Texts = {},
  ) {
    super(`${statusCode} ${key}`);
    this.name = 'ApiError';
  }

  // eine Fehlerantwort des HTTP-Clients von Angular -> ein ApiError
  static fromResponse(response: HttpErrorResponse): ApiError {
    // Status 0: keine Antwort (Netz ausgefallen, Server gestoppt, falsche Adresse)
    if (response.status === 0) {
      return new ApiError(0, 'ERRORS.SERVER_UNREACHABLE');
    }
    // error: der Body der Antwort, bereits dekodiert, wenn es JSON ist
    const body: unknown = response.error;
    if (isObject(body) && typeof body['key'] === 'string') {
      return new ApiError(response.status, body['key'], texts(body['params']), texts(body['fields']));
    }
    // kein key: Der Proxy oder das Netz hat an seiner Stelle geantwortet
    return new ApiError(
      response.status,
      response.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR',
    );
  }
}

function isObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

// ein JSON-Objekt { "name": "ERRORS..." } -> Texts (sonst leer)
function texts(json: unknown): Texts {
  if (!isObject(json)) return {};
  return Object.fromEntries(Object.entries(json).map(([key, value]) => [key, String(value)]));
}

Die aus Beispiel 24: Jede fehlgeschlagene Anfrage endet mit einem [ApiError], der den Übersetzungsschlüssel der Meldung, ihre Parameter und den Fehler je Feld enthält.

  • Zeile 21: [extends Error]: ein vollwertiger [JavaScript]-Fehler. Das ist wichtig für die Ressourcen von [Angular] ([resource()], später behandelt): Ihr Signal [error()] behält einen [Error] unverändert bei, „verpackt“ aber jeden anderen abgelehnten Wert;
  • Zeilen 22–27: Konstruktorparameter mit vorangestelltem [readonly] werden zu Eigenschaften des Objekts: Das ist eine Kurzschreibweise von [TypeScript];
  • Zeilen 35–37: [status] ist 0, wenn keine Antwort eingegangen ist (Netzwerk ausgefallen, Server ausgefallen, falsche Adresse);
  • Zeilen 39–42: [response.error]: der Body der Fehlerantwort, vom HTTP-Client bereits dekodiert, wenn es JSON ist. Sein Typ ist [unknown]: Sein Format wird geprüft ([isObject], ein Schlüssel [key] vom Typ Text), bevor er verwendet wird;
  • Zeilen 44–47: kein Schlüssel: Der Proxy oder das Netzwerk hat anstelle des Servers geantwortet;
  • Zeile 51: [value is Record<string, unknown>]: eine „Type Guard“-Funktion: Gibt sie [true] zurück, weiß [TypeScript] weiter unten im Code, dass der Wert ein Objekt ist;
  • Zeilen 56–59: ein JSON-Objekt ([params], [fields]) als Textobjekt.

11.7.4. src/app/api/types.ts

// =========================================================================
// src/app/api/types.ts - die mit dem Server ausgetauschten JSON-Objekte
// -------------------------------------------------------------------------
// Die Übersetzung der im Kapitel "Der
// Server, eine Blackbox" beschriebenen API in TypeScript-Typen. Sie sind nur BESCHREIBUNGEN: Sie
// verschwinden beim Kompilieren und prüfen während der
// Ausführung nichts. Sie lassen den Compiler prüfen, dass der Code
// nur existierende Felder mit dem richtigen Typ verwendet.
// =========================================================================

export type Role = 'ADMIN' | 'DOCTOR' | 'USER';

// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
export interface User {
  login: string;
  name: string; // angezeigter Name: "Marie PELISSIER"
  role: Role;
}

// GET /api/captcha
export interface Captcha {
  id: string;
  svg: string; // das Bild im SVG-Format (Text)
}

// ein Titel, ein Vorname, ein Nachname
export interface Identity {
  title: string;
  firstName: string;
  lastName: string;
}

// "Mme Alice DURAND"
export function label(i: Identity): string {
  return `${i.title} ${i.firstName} ${i.lastName}`;
}

// ein Arzt oder ein Client: GET /api/doctors, GET /api/clients/:id ...
export interface Person extends Identity {
  id: number;
  version: number; // optimistisches Sperren: wird bei einer Änderung zurückgesendet
  login?: string; // nur für den ADMIN
}

// ein Zeitfenster
export interface Slot {
  id: number;
  startHour: number;
  startMinute: number;
  endHour: number;
  endMinute: number;
}

// eine Zeile des Terminkalenders mit den RECHTEN des angemeldeten Benutzers
export interface ScheduleSlot extends Slot {
  free: boolean;
  patient: Identity | null; // null: frei oder von einem anderen Patienten belegt
  mine: boolean; // der Termin des angemeldeten Patienten
  bookable: boolean;
  appointmentId: number | null; // gesetzt, wenn der Benutzer stornieren kann
}

// GET /api/schedule?doctorId=...&day=...
export interface Schedule {
  doctor: Person;
  day: string; // "yyyy-MM-dd"
  slots: ScheduleSlot[];
  info: string | null; // Übersetzungsschlüssel (Patient, der bereits einen Termin hat)
}

// ein Termin von GET /api/my-area
export interface Appointment {
  id: number;
  day: string;
  slot: Slot;
  doctor: Person;
}

// GET /api/my-area
export interface MyArea {
  patient: Identity;
  appointments: Appointment[];
}

// GET /api/my-account
export interface MyAccount extends Identity {
  login: string;
  version: number;
}

Die JSON-Objekte der API, vom Typ [TypeScript] (siehe Beispiel 24). Es sind lediglich BESCHREIBUNGEN: Sie verschwinden beim Kompilieren und führen zur Laufzeit keine Prüfungen durch (der [Flutter]-Client dagegen prüfte das Format jeder Antwort durch Filtern mit [Dart] 3). Sie erlauben dem Compiler und dem Editor zu prüfen, dass der Code nur vorhandene Felder mit dem richtigen Typ verwendet.

  • Zeile 11: ein „Text-Union“-Typ: Eine Rolle kann nur einer dieser drei Strings sein, und der Compiler prüft das ([u.role === 'ADMNI'] wäre ein Kompilierfehler);
  • Zeilen 34–36: eine Funktion, da ein Interface keinen Code enthalten kann: „Mme Alice DURAND“;
  • Zeilen 39–43: ein Arzt oder ein Kunde: eine [Identity] plus ein Bezeichner, eine Version (das optimistische Sperren: Sie wird bei einer Änderung zurückgesendet) und ein Login, das nur der ADMIN erhält (daher das Fragezeichen: ein optionales Feld);
  • Zeilen 55–61: Ein Eintrag im Terminkalender, der die vom Server berechneten RECHTE des angemeldeten Benutzers zeigt: [patient] wird nur denjenigen angezeigt, die es sehen dürfen, [bookable] gibt an, ob der Benutzer eine Buchung vornehmen kann; [appointmentId] wird nur denjenigen geliefert, die stornieren können;
  • Zeilen 86–89: das Konto des angemeldeten Patienten: seine Identität, sein Login und seine Version.

11.7.5. src/app/api/rdvmedecins-api.ts

// =========================================================================
// src/app/api/rdvmedecins-api.ts - eine Methode pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients: Die Bildschirme rufen diese
// typisierten Methoden auf, ohne etwas über die URLs, den HTTP-Client oder das JSON zu wissen.
// Ändert sich die API, ändert sich nur diese Datei.
// Jede Methode liefert ein Promise; bei einem Fehlschlag wird es
// mit einem ApiError zurückgewiesen (siehe http-client.ts).
// Die gesendeten Daten (Formulare) sind einfache Data-Objekte:
// Ihre Schlüssel sind die Namen der vom Server erwarteten Felder - und die
// der Fehler, die er zurückschickt (ApiError.fields).
// =========================================================================

import { inject, Injectable } from '@angular/core';
import { ApiClient } from './api-client';
import { Schedule, Captcha, MyAccount, MyArea, Person, User } from './types';

// /api/doctors oder /api/clients: Beide werden gleich behandelt
export type PersonType = 'doctors' | 'clients';

export type Data = Record<string, unknown>;

@Injectable({ providedIn: 'root' })
export class RdvMedecinsApi {
  private readonly client = inject(ApiClient);

  private get<T>(url: string, isPublic = false): Promise<T> {
    return this.client.request<T>('GET', url, undefined, isPublic);
  }

  private post<T>(url: string, body: unknown, isPublic = false): Promise<T> {
    return this.client.request<T>('POST', url, body, isPublic);
  }

  // ================================================ Anmeldung (öffentliche Routen)
  captcha(): Promise<Captcha> {
    return this.get('/captcha', true);
  }

  me(): Promise<User> {
    return this.get('/auth/me', true);
  }

  logIn(login: string, password: string, captchaId: string, captcha: string): Promise<User> {
    return this.post('/auth/login', { login, password, captchaId, captcha }, true);
  }

  async logOut(): Promise<void> {
    await this.post('/auth/logout', {}, true);
  }

  // ================================================ Kontoerstellung (öffentlich)
  async registrationAccess(captchaId: string, captcha: string): Promise<void> {
    await this.post('/register/access', { captchaId, captcha }, true);
  }

  async registrationAccessStatus(): Promise<boolean> {
    const response = await this.get<{ valid?: boolean }>('/register/access', true);
    return response?.valid === true;
  }

  async register(data: Data): Promise<string> {
    const response = await this.post<{ login: string }>('/register', data, true);
    return response.login;
  }

  // ================================================ Terminkalender und Termine
  // doctorId undefined: bei einem angemeldeten Arzt SEIN Terminkalender
  schedule(doctorId: number | undefined, day: string): Promise<Schedule> {
    // URLSearchParams: "day=2026-10-05&doctorId=1", Sonderzeichen kodiert
    const params = new URLSearchParams({ day });
    if (doctorId !== undefined) params.set('doctorId', String(doctorId));
    return this.get(`/schedule?${params}`);
  }

  async book(day: string, slotId: number, clientId: number | undefined): Promise<void> {
    // clientId: undefined verschwindet aus dem gesendeten JSON
    await this.post('/appointments', { day, slotId, clientId });
  }

  async cancelAppointment(appointmentId: number): Promise<void> {
    await this.client.request('DELETE', `/appointments/${appointmentId}`);
  }

  // ================================================ Ärzte und Clients
  list(type: PersonType): Promise<Person[]> {
    return this.get(`/${type}`);
  }

  read(type: PersonType, id: number): Promise<Person> {
    return this.get(`/${type}/${id}`);
  }

  add(type: PersonType, data: Data): Promise<Person> {
    return this.post(`/${type}`, data);
  }

  edit(type: PersonType, id: number, data: Data): Promise<Person> {
    return this.client.request('PUT', `/${type}/${id}`, data);
  }

  async remove(type: PersonType, id: number): Promise<void> {
    await this.client.request('DELETE', `/${type}/${id}`);
  }

  // ================================================ der Bereich des Patienten
  myArea(): Promise<MyArea> {
    return this.get('/my-area');
  }

  myAccount(): Promise<MyAccount> {
    return this.get('/my-account');
  }

  editMyAccount(data: Data): Promise<User> {
    return this.client.request('PUT', '/my-account', data);
  }

  async deleteMyAccount(currentPassword: string): Promise<void> {
    await this.client.request('DELETE', '/my-account', { currentPassword });
  }
}

Eine Methode pro Route der API: Das ist die erweiterte Klasse aus Beispiel 24.

  • Zeile 19: [/api/doctors] und [/api/clients] werden gleich behandelt: Der Typ – eine Union aus zwei Strings – ist zugleich der Routenname;
  • Zeile 21: Formulardaten: ein Objekt, dessen Schlüssel Strings sind und dessen Werte beliebig sein können;
  • Zeilen 23–25: Ein für die gesamte Anwendung bereitgestellter Service, der den [ApiClient] per Injektion erhält;
  • Zeilen 35–50: die öffentlichen Routen für die Anmeldung: Eine 401 hat hier eine eigene Bedeutung („niemand ist angemeldet“, „falsches Passwort“) und bedeutet nicht, dass die Sitzung abgelaufen ist;
  • Zeilen 48–50: eine [async]-Methode, die nichts zurückgibt ([Promise<void>]): Die Antwort des Servers interessiert uns nicht; nur der Erfolg zählt;
  • Zeilen 57–60: Ist der Token zur Kontoerstellung gültig? [response?.valid]: Der Operator [?.] liefert [undefined] , wenn die Antwort leer ist, statt einen Fehler auszulösen;
  • Zeilen 69–74: die Adressparameter, von [URLSearchParams] aufgebaut (das sie kodiert). Ein angemeldeter Arzt fordert den Terminkalender ohne [doctorId] an: Der Server liefert den eigenen Terminkalender des Arztes;
  • Zeile 78: ebenso wird [clientId] nur gesendet, wenn es bekannt ist (ein Patient bucht für sich selbst): [JSON.stringify] lässt die Eigenschaften weg, die [undefined] entsprechen;
  • Zeilen 86–104: die fünf Operationen für Ärzte oder Kunden: [/api/${type}];
  • Zeilen 107–121: der Bereich des Patienten. Das Löschen des Kontos sendet einen Body mit einer [DELETE]-Anfrage (das aktuelle Passwort): Das ist von HTTP und von [http.request] erlaubt.

11.8. Sprachen

11.8.1. src/app/i18n/translations.ts

// =========================================================================
// src/app/i18n/translations.ts - die Wörterbücher, die aktuelle Sprache
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 21. Die Wörterbücher (public/i18n/fr.json, en.json)
// sind die der Clients in Vue.js, Angular, React und Flutter: gleiche Schlüssel,
// gleiche Konventionen ({{param}}, Plurale _one / _other). Der Server sendet nur
// SCHLÜSSEL zurück ("ERRORS.LOGIN_TAKEN"): Hier werden sie zu Text,
// in der vom Benutzer gewählten Sprache.
//   - t('KEY', { param: value }) : der Text der aktuellen Sprache;
//   - changeLanguage('fr')       : lädt das andere Wörterbuch und
//                                  merkt sich die Wahl auf dem Gerät.
// Die Sprache und das Wörterbuch sind SIGNALS: t() liest sie, daher wird jedes
// Template, das t('...') anzeigt, bei einem Sprachwechsel aktualisiert.
// =========================================================================

import { Injectable, signal } from '@angular/core';
import { Preferences } from '@capacitor/preferences';

export const languages = ['fr', 'en'] as const;
export type Language = (typeof languages)[number]; // 'fr' | 'en'

// ein Wörterbuch: Texte, in verschachtelten Abschnitten gespeichert
interface Dictionary {
  [key: string]: string | Dictionary;
}

const LANGUAGE_KEY = 'rdvmedecins.language';

@Injectable({ providedIn: 'root' })
export class Translations {
  private readonly _language = signal<Language>('en');
  private readonly dictionary = signal<Dictionary>({});
  readonly language = this._language.asReadonly();

  // die Startsprache: die auf dem Gerät gemerkte, sonst die des
  // Telefons (falls bekannt), sonst Englisch. Einmal aufgerufen,
  // bevor der erste Bildschirm angezeigt wird (provideAppInitializer, main.ts)
  async start(): Promise<void> {
    // Preferences: ein Schlüssel-Wert-Speicher auf dem Gerät (der
    // localStorage des Browsers im Web)
    const { value: stored } = await Preferences.get({ key: LANGUAGE_KEY });
    const device = navigator.language.slice(0, 2); // "en-US" -> "en"
    await this.changeLanguage(stored ?? device);
  }

  async changeLanguage(requested: string): Promise<void> {
    const language: Language = languages.find((l) => l === requested) ?? 'en';
    // fetch: Die Dateien des Ordners public/ werden mit der Anwendung ausgeliefert
    // (auch unter Android: Eine RELATIVE Adresse läuft nicht über CapacitorHttp)
    const response = await fetch(`i18n/${language}.json`);
    this.dictionary.set((await response.json()) as Dictionary);
    this._language.set(language);
    await Preferences.set({ key: LANGUAGE_KEY, value: language });
  }

  // "AREA.HELLO" -> dictionary['AREA']['HELLO']; undefined, falls nicht vorhanden
  private find(key: string): string | undefined {
    let node: string | Dictionary | undefined = this.dictionary();
    for (const part of key.split('.')) {
      node = typeof node === 'object' ? node[part] : undefined;
    }
    return typeof node === 'string' ? node : undefined;
  }

  // eine Pfeilfunktion: Sie kann unverändert an die Komponenten übergeben werden
  // (readonly t = inject(Translations).t), sie behält ihr "this"
  readonly t = (key: string, params: Record<string, unknown> = {}): string => {
    let text: string | undefined;
    const count = params['count'];
    if (typeof count === 'number') {
      // Intl.PluralRules: die Pluralform nach den Regeln der
      // Sprache ('zero', 'one', 'other' ...); 0 ist im Französischen 'one'
      const form = new Intl.PluralRules(this._language()).select(count);
      text = this.find(`${key}_${count === 0 ? 'zero' : form}`) ?? this.find(`${key}_${form}`);
    }
    text ??= this.find(key);
    // ein unbekannter Schlüssel wird unverändert angezeigt: Was fehlt, sieht man sofort
    if (text === undefined) return key;
    // {{name}} -> der Wert des Parameters name
    return text.replace(/\{\{(\w+)\}\}/g, (whole, name: string) => (name in params ? String(params[name]) : whole));
  };
}

Die Klasse [Translations] aus Beispiel 21, nun ein für die gesamte Anwendung bereitgestellter und vereinfachter Service: Die Wörterbücher heißen weiterhin gleich ([public/i18n/fr.json]).

  • Zeile 19: [as const]: Das Array ist fest, und sein Typ ist genau [readonly ['fr', 'en']]; Zeile 20 leitet den Typ [Language] ab, ['fr' | 'en']: Wird dem Array eine Sprache hinzugefügt, kommt sie auch zum Typ hinzu;
  • Zeilen 23–25: ein Wörterbuch: Texte, in verschachtelten Abschnitten organisiert (ein rekursiver Typ);
  • Zeilen 31–33: Die Sprache und das Wörterbuch sind SIGNALE. Alles, was [t(...)] liest (ein Template, ein berechnetes Signal, ein Effekt), liest auch diese Signale und aktualisiert sich daher bei einem Sprachwechsel selbst: Es ist das [notifyListeners()] des [ChangeNotifier] von [Flutter], ohne dass man etwas schreiben muss. [asReadonly()]: Der Rest der Anwendung kann die Sprache lesen, aber nur dieser Service kann sie ändern;
  • Zeilen 38–44: die Standardsprache: die in einer früheren Sitzung gewählte, andernfalls die Sprache des Smartphones, sofern die App sie kennt, andernfalls Englisch. [Preferences] (das Plugin von [Capacitor], siehe Beispiel 20) speichert Schlüssel-Wert-Paare auf dem Gerät; in einem Browser verwendet es [localStorage]. [navigator.language]: die Systemsprache („en-US“);
  • Zeilen 46–54: Sprache wechseln: Das Wörterbuch wird per [fetch] aus den mit der Anwendung ausgelieferten Dateien gelesen (der Ordner [public/], von [ng build] unverändert kopiert). Unter [Android] wird eine RELATIVE URL ([i18n/fr.json]) nicht von [CapacitorHttp] umgeleitet: Sie wird von der Anwendung selbst ausgeliefert. Die unbekannte Sprache wird zu Englisch;
  • Zeilen 57–63: „AREA.HELLO“ → [dictionary['AREA']['HELLO']], Abschnitt für Abschnitt vorgehend;
  • Zeilen 67–81: die Übersetzung eines Schlüssels, einschließlich Pluralformen ([_zero], [_one], [_other]) und Parametern ([{{name}}]), nach den Konventionen von [i18next], die dieselben sind wie in den Wörterbüchern der anderen Clients. [Intl.PluralRules] kennt die Pluralregeln jeder Sprache (im Französischen sind 0 und 1 Singular). [t] ist eine Arrow-Funktion, keine Methode: Sie behält ihr [this] , wenn sie in eine Komponente kopiert wird ([readonly t = inject(Translations).t]), was alle Bildschirme tun.

11.8.2. Wörterbücher

Die Wörterbücher sind die des [Flutter]-Clients, unverändert (selbst dem [React]-Client entnommen und um einige für die mobile App spezifische Schlüssel ergänzt: das Menü „Mein Konto“, „Tag wählen“ usw.). Der Anfang des französischen Wörterbuchs [public/i18n/fr.json]:

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

Eine Datei pro Sprache, in jeder mit denselben Schlüsseln; eine Schlüsselgruppe pro Bildschirm; die Schlüssel [ERRORS.*] sind die vom Server zurückgegebenen.

11.9. Der gemeinsame Zustand

Drei Signal-Services, für die gesamte Anwendung bereitgestellt ([providedIn: 'root']), wie der aus Beispiel 20.

11.9.1. src/app/state/session.ts

// =========================================================================
// src/app/state/session.ts - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der angemeldete Benutzer (oder null) in einem SERVICE mit Signals, der der
// gesamten Anwendung bereitgestellt wird (providedIn: 'root', siehe Beispiel 20): lesbar von den
// Bildschirmen UND von den Router-Guards, die bei einer Änderung neu ausgewertet werden
// (siehe app.ts).
//
// Der JWT-Token selbst ist NICHT hier: Er steckt in einem Cookie (im Web vom
// Browser verwaltet, auf dem Telefon vom nativen Code von Android). Die
// Sitzung behält nur die BESCHREIBUNG des Benutzers ({ login, name, role }).
//
// Beim Start der Anwendung ist die Sitzung leer: check() fragt
// den Server, nur einmal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================

import { inject, Injectable, signal } from '@angular/core';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { User } from '../api/types';

@Injectable({ providedIn: 'root' })
export class Session {
  private readonly api = inject(RdvMedecinsApi);
  private readonly _user = signal<User | null>(null);
  // die "schreibgeschützte" Version des Signals, für den Rest der Anwendung
  readonly user = this._user.asReadonly();
  // true nach einer GEWOLLTEN Abmeldung (Schaltfläche, Kontolöschung); false
  // nach einer abgelaufenen Sitzung. Die Guards berücksichtigen es (siehe app.routes.ts)
  private _voluntaryExit = false;
  // wurde die Frage "wer ist angemeldet?" dem Server bereits gestellt?
  private checking?: Promise<void>;

  get voluntaryExit(): boolean {
    return this._voluntaryExit;
  }

  // fragt den Server nur beim ersten Mal (das Promise wird behalten)
  check(): Promise<void> {
    this.checking ??= this.api.me().then(
      (u) => this.change(u),
      () => this.change(null), // 401: niemand; oder Server nicht erreichbar
    );
    return this.checking;
  }

  async logIn(login: string, password: string, captchaId: string, captcha: string): Promise<void> {
    this.change(await this.api.logIn(login, password, captchaId, captcha));
  }

  // der Benutzer hat Namen oder Login geändert (PUT /api/my-account)
  update(u: User): void {
    this.change(u);
  }

  async logOut(): Promise<void> {
    try {
      await this.api.logOut();
    } finally {
      this.forget(true);
    }
  }

  // ohne den Server etwas zu fragen: Sitzung abgelaufen, Konto gelöscht
  forget(voluntary = false): void {
    this.change(null, voluntary);
  }

  // das Signal ändert sich: Alles, was es liest (Layout, Guards ...), wird benachrichtigt
  private change(u: User | null, voluntary = false): void {
    this._voluntaryExit = voluntary;
    this._user.set(u);
  }
}

// was aus dem Benutzer abgeleitet wird (null: niemand ist angemeldet)
export const isAdmin = (u: User | null): boolean => u?.role === 'ADMIN';
export const isPatient = (u: User | null): boolean => u?.role === 'USER';
// ADMIN und DOCTOR: Sie buchen und stornieren die Termine beliebiger Patienten
export const isManager = (u: User | null): boolean => u?.role === 'ADMIN' || u?.role === 'DOCTOR';
// die Startseite jeder Rolle, direkt nach der Anmeldung
export const homePage = (u: User | null): string => (isPatient(u) ? '/my-area' : '/schedule');

Wer ist angemeldet? Die Sitzung speichert die BESCHREIBUNG des Benutzers (Login, Name, Rolle), nicht den Token, der im Cookie des Benutzers bleibt.

  • Zeilen 24–26: der Benutzer in einem privaten, änderbaren Signal ([_user]) und seine schreibgeschützte Version für den Rest der Anwendung. Das Layout (das den Namen des Benutzers anzeigt), [app.ts] (das den Cache leert und die Guards neu auswertet) und die Bildschirme lesen diese Information;
  • Zeilen 38–44: Die an den Server gesendete Frage „Wer ist angemeldet?“ ([GET /api/auth/me]) wird nur EINMAL gestellt, beim Start: [??=] weist das [Promise] nur zu, wenn [checking] den Wert [undefined] hat. Spätere Aufrufe liefern dasselbe, bereits aufgelöste [Promise]: Der Guard des Routers kann [check()] vor jeder Navigation ohne Kosten aufrufen. Enthält das Cookie beim Start einen noch gültigen Token, bleibt der Benutzer angemeldet. [then(success, failure)]: Eine 401 (niemand ist angemeldet) oder ein nicht erreichbarer Server führen beide zu einer leeren Sitzung;
  • Zeilen 46–48: die Anmeldung: Lehnt der Server ab, weist [api.logIn] sein [Promise] mit einem [ApiError] zurück, [await] wirft ihn erneut, und [change] wird nicht aufgerufen;
  • Zeilen 55–61: Abmeldung – der Benutzer wird auch dann vergessen, wenn der Server nicht antwortet ([finally]);
  • Zeilen 69–72: Alle Änderungen laufen hier zusammen. [_voluntaryExit] unterscheidet zwischen einer beabsichtigten Abmeldung und einer abgelaufenen Sitzung (siehe [app.routes.ts]); es wird gesetzt, BEVOR das Signal geändert wird, das die Guards lesen;
  • Zeilen 76–81: was über den Benutzer abgeleitet wird, in Form von Funktionen (der Client [Flutter] verwendete eine Erweiterung von [Dart]). [u?.role]: [undefined] , wenn niemand angemeldet ist ([null]), ohne vorherige Prüfung.

11.9.2. src/app/state/messages.ts

// =========================================================================
// src/app/state/messages.ts - die dem Benutzer angezeigten Meldungen
// -------------------------------------------------------------------------
// Gleiche Darstellung wie bei den anderen RdvMedecins-Clients:
//   - ein ERFOLG wird OBEN am Bildschirm angezeigt (grünes Banner);
//   - ein FEHLER UNTEN (rosa Banner), immer sichtbar.
// Eine Meldung ist ein Übersetzungs-SCHLÜSSEL (+ seine Parameter): Sie wird daher
// von selbst neu übersetzt, wenn der Benutzer die Sprache wechselt.
//
// Die "Flash"-Meldungen: Eine Aktion, die mit einem Bildschirmwechsel endet
// (Buchung, Hinzufügen eines Arztes ...), hinterlässt ihre Meldung mit
// flash(); sie wird auf dem NÄCHSTEN Bildschirm angezeigt und verschwindet bei der
// darauffolgenden Navigation. Es ist app.ts, das newPage() am Ende
// jeder Navigation aufruft.
// =========================================================================

import { effect, inject, Injectable, Resource, signal, untracked } from '@angular/core';
import { ApiError, Texts } from '../api/api-error';

export interface Message {
  key: string;
  params: Texts;
}

@Injectable({ providedIn: 'root' })
export class Messages {
  readonly success = signal<Message | null>(null);
  readonly error = signal<Message | null>(null);
  // die Meldungen, die auf dem nächsten Bildschirm anzuzeigen sind
  private pendingSuccess: Message | null = null;
  private pendingError: Message | null = null;

  showSuccess(key: string, params: Texts = {}): void {
    this.success.set({ key, params });
    this.error.set(null);
  }

  showError(key: string, params: Texts = {}): void {
    this.error.set({ key, params });
    this.success.set(null);
  }

  // ein ApiError -> die Meldung des Bildschirms; jeder andere Fehler ist eine
  // Anomalie des Clients, die durchgelassen wird
  showApiError(e: unknown): void {
    if (!(e instanceof ApiError)) throw e;
    this.showError(e.key, e.params);
  }

  clear(): void {
    this.success.set(null);
    this.error.set(null);
  }

  // für den NÄCHSTEN Bildschirm
  flash({ success = true, key, params = {} }: { success?: boolean; key: string; params?: Texts }): void {
    if (success) {
      this.pendingSuccess = { key, params };
    } else {
      this.pendingError = { key, params };
    }
  }

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

// im Konstruktor eines Bildschirms aufzurufen: Das Scheitern beim Lesen dieser
// Ressourcen (Angular-Resource) zeigt seine Meldung unten am Bildschirm an
export function reportErrors(...resources: Resource<unknown>[]): void {
  const messages = inject(Messages);
  for (const resource of resources) {
    // ein Effect: eine Funktion, die jedes Mal erneut ausgeführt wird, wenn sich ein
    // von ihr gelesenes Signal ändert (hier der Fehler der Resource)
    effect(() => {
      const error = resource.error();
      // untracked: Was folgt, darf keine Abhängigkeit des Effects werden
      if (error) untracked(() => messages.showApiError(error));
    });
  }
}

Meldungen der Anwendung: eine Erfolgsmeldung oben auf dem Bildschirm, eine Fehlermeldung unten (siehe [layout.html]).

  • Zeilen 20–23: Eine Meldung besteht aus einem Übersetzungscode (KEY) und seinen Parametern. Sie wird erst bei der Anzeige übersetzt; ein Sprachwechsel übersetzt die angezeigten Meldungen neu;
  • Zeilen 27–28: Die angezeigten Erfolgs- und Fehlermeldungen: zwei Signale, die vom Layout gelesen werden;
  • Zeilen 45–48: Ein [ApiError] wird zur Fehlermeldung des Screens. Jede andere Ausnahme ist ein clientseitiges Problem: Sie wird erneut ausgelöst, damit sie während der Entwicklung in der Konsole erscheint, statt verborgen zu bleiben;
  • Zeilen 56–62: eine Meldung für den NÄCHSTEN Screen: Eine Aktion, die mit einem Screenwechsel endet (eine Reservierung, ein Hinzufügen usw.), legt ihre Meldung hier ab. Der Parameter ist ein „entpacktes“ Objekt: [flash({ success: false, key: '...' })], mit Standardwerten; das entspricht den benannten Parametern von [Dart];
  • Zeilen 66–71: wird bei jeder Änderung der Adresse aufgerufen (siehe [app.ts]): Die Meldungen des vorherigen Screens verschwinden, und die Flash-Meldungen erscheinen;
  • Zeilen 76–87: eine Funktion, die im Konstruktor eines Screens aufzurufen ist: Schlägt das Lesen seiner Ressourcen fehl ([resource()], siehe [schedule.ts]), wird ihre Meldung unten auf dem Bildschirm angezeigt. Für jede Ressource liest ein Effekt ihr Signal [error()]: Er wird bei jedem neuen Fehler erneut ausgeführt. Ein Effekt kann nur in einem Injektionskontext erstellt werden, etwa bei [inject()]: daher die Vorgabe, die Funktion in einem Konstruktor (oder bei der Initialisierung eines Felds) aufzurufen.

11.9.3. src/app/state/cache.ts

// =========================================================================
// src/app/state/cache.ts - die bereits vom Server gelesenen Daten
// -------------------------------------------------------------------------
// Die Liste der Ärzte ändert sich fast nie: Es ist nicht nötig, sie bei
// jedem Besuch des Terminkalenders erneut zu lesen. Der Cache behält das Promise jedes Lesevorgangs
// unter einem SCHLÜSSEL ('doctors', 'schedule/1/2026-10-05' ...):
//
//     cache.read('doctors', () => api.list('doctors'))
//
// liefert das bereits behaltene Promise oder startet das Lesen und behält es.
// Nach einer Änderung werden die betroffenen Schlüssel für UNGÜLTIG erklärt (sie werden
// bei der nächsten Anfrage erneut gelesen): cache.invalidate('schedule').
// Ein gescheitertes Lesen wird nicht behalten: Das nächste versucht es erneut.
// Jede Invalidierung erhöht das Signal version: Ein noch lebender Bildschirm
// (auch einer, der im Stapel von Ionic unter einem anderen versteckt ist) kann so
// seine Daten erneut lesen (siehe reloadAfterInvalidation, unten).
// Das ist, in wenigen Zeilen, was die Bibliothek TanStack Query des
// React-Clients leistet.
// =========================================================================

import { effect, inject, Injectable, signal, untracked, WritableResource } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class Cache {
  private readonly promises = new Map<string, Promise<unknown>>();
  private readonly _version = signal(0);
  readonly version = this._version.asReadonly();

  read<T>(key: string, load: () => Promise<T>): Promise<T> {
    let promise = this.promises.get(key) as Promise<T> | undefined;
    if (promise === undefined) {
      promise = load();
      this.promises.set(key, promise);
      // bei einem Fehlschlag wird dieses Promise vergessen (die nächste Anfrage versucht es erneut)
      promise.catch(() => this.promises.delete(key));
    }
    return promise;
  }

  // vergisst alle Schlüssel, die mit prefix beginnen, und benachrichtigt die Bildschirme
  invalidate(prefix: string): void {
    for (const key of [...this.promises.keys()]) {
      if (key.startsWith(prefix)) this.promises.delete(key);
    }
    this._version.update((v) => v + 1);
  }

  // Benutzerwechsel: Alles wird vergessen, OHNE Benachrichtigung (die Bildschirme des
  // vorherigen Benutzers verschwinden gleich, sie dürfen nichts lesen)
  clear(): void {
    this.promises.clear();
  }
}

// im Konstruktor eines Bildschirms aufzurufen: Seine Resources werden nach jeder
// Invalidierung des Caches erneut gelesen (reload). reload() behält den aktuellen
// Wert während des neuen Lesens: Der Bildschirm "flackert" nicht
export function reloadAfterInvalidation(...resources: WritableResource<unknown>[]): void {
  const cache = inject(Cache);
  const start = cache.version();
  effect(() => {
    // der Effect läuft beim Erzeugen ein erstes Mal: Wir warten auf eine
    // ECHTE Invalidierung
    if (cache.version() === start) return;
    untracked(() => resources.forEach((r) => r.reload()));
  });
}

Bereits vom Server gelesene Daten: das Äquivalent von [TanStack Query] im Client [React] und von [Cache] im Client [Flutter] in wenigen Zeilen.

  • Zeile 25: Der Cache speichert [Promise]-Objekte, keine tatsächlichen Werte: Zwei Screens, die dieselben Daten anfordern, während diese unterwegs sind, erhalten DASSELBE [Promise], und es wird nur eine einzige Anfrage gesendet;
  • Zeilen 29–38: Eine generische Methode: [read<Person[]>(...)] liefert ein [Promise<Person[]>] (der Typ [T] wird aus der Funktion [load] abgeleitet). Ein fehlgeschlagenes Lesen wird ignoriert ([catch]): Die nächste Anfrage versucht es erneut;
  • Zeilen 41–46: Nach einer Änderung werden die betroffenen Schlüssel verworfen, und das Signal [version] wird erhöht: Screens, die dieses Signal lesen, werden benachrichtigt;
  • Zeilen 50–52: Wechselt der Benutzer, wird alles geleert, ohne jemanden zu benachrichtigen: Die Screens des vorherigen Benutzers verschwinden; sie haben nichts neu zu lesen;
  • Zeilen 58–67: eine Funktion, die im Konstruktor eines Screens aufzurufen ist: Seine Ressourcen werden nach jeder Cache-Invalidierung neu gelesen. Der Effekt liest [cache.version()]: Er wird bei jeder Invalidierung erneut ausgeführt und liest die Ressourcen neu ([reload()]). Die Screens von [Ionic] bleiben aktiv, verborgen unter dem angezeigten Screen (der Stapel der Zurück-Schaltfläche): Nach einer Änderung sind sie bei der Rückkehr bereits auf dem neuesten Stand. [reload()] behält den aktuellen Wert während des erneuten Lesens bei: Der Screen „flackert“ nicht.

11.10. Formatierung

11.10.1. src/app/formatting.ts

// =========================================================================
// src/app/formatting.ts - die Anzeige von Uhrzeiten und Tagen
// -------------------------------------------------------------------------
// Der Server sendet ROHE Daten (startHour: 8, startMinute: 0; day:
// "2026-10-05"); die Formatierung, die von der Sprache abhängt, ist Sache
// des Clients (siehe Beispiel 09). Wir verwenden hier die Intl-API von JavaScript,
// die die Regeln aller Sprachen kennt.
// =========================================================================

import { Slot } from './api/types';

const two = (n: number): string => n.toString().padStart(2, '0');

// "8:05" statt "8:5"
export const time = (h: number, m: number): string => `${h}:${two(m)}`;

// "8:00 - 8:20"
export const timeRange = (s: Slot): string => `${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}`;

// ein Datum -> "yyyy-MM-dd" (das Format der API), in der Zeitzone des Geräts
export const toDay = (d: Date): string => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;

export const today = (): string => toDay(new Date());

// "2026-10-05" -> 5. Oktober 2026 um 0:00 Uhr, Ortszeit (new Date("2026-10-05")
// würde 0:00 Uhr in Weltzeit liefern: am Vorabend, auf einem anderen Kontinent)
export function toDate(day: string): Date {
  const [y, m, d] = day.split('-').map(Number);
  return new Date(y, m - 1, d);
}

// true, wenn day ein existierendes Datum im Format yyyy-MM-dd ist
export function isValidDate(day: string): boolean {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return false;
  return toDay(toDate(day)) === day; // 2026-02-30 -> 2026-03-02: abgelehnt
}

// "lundi 5 octobre 2026" / "Monday, October 5, 2026"
export function longDay(day: string, language: string): string {
  return new Intl.DateTimeFormat(language, { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric' }).format(
    toDate(day),
  );
}

Formatierung der Rohdaten des Servers (siehe Beispiel 09):

  • Zeile 21: ein Datum im API-Format („2026-10-05“) in der Zeitzone des Geräts. [getMonth()] zählt die Monate ab 0;
  • Zeilen 27–30: die Umkehrung: „2026-10-05“ → 5. Oktober, 00:00 Uhr Ortszeit. [new Date('2026-10-05')] würde Mitternacht in koordinierter Weltzeit (UTC) bedeuten, also westlich von Greenwich am Vorabend;
  • Zeilen 33–36: Ist das Datum in der Adresse gültig? [new Date(2026, 1, 30)] ergibt den 2. März: Wir prüfen, ob derselbe String zurückgegeben wird;
  • Zeilen 39–43: „Montag, 5. Oktober 2026“, abhängig von der Sprache: [Intl.DateTimeFormat] – die Formatierungsvariante von [JavaScript] – unterstützt alle Sprachen. Der Client [Flutter] benötigte dafür das Paket [intl].

11.11. Der Router

11.11.1. src/app/app.routes.ts

// =========================================================================
// src/app/app.routes.ts - die Bildschirme der Anwendung und ihre Zugriffsrechte
// -------------------------------------------------------------------------
// Dieselben Adressen wie bei den anderen Clients (/login, /schedule, /doctors,
// /my-area ...). Im Web werden sie in der Adressleiste angezeigt;
// auf dem Telefon bleiben sie unsichtbar, organisieren die Anwendung aber
// genauso (und den Stapel der Bildschirme der Zurück-Taste).
//
// Die GUARDS: Die Guard-Funktion (eine CanActivateFn) wird vor
// JEDER Navigation zu jedem Bildschirm aufgerufen. Sie ist asynchron: Beim ersten
// Mal (Anwendungsstart, F5 im Web) wartet sie auf die Antwort des Servers
// auf die Frage "wer ist angemeldet?" (session.check()). Dann
// prüft sie die Rechte des angeforderten Bildschirms (accessOf) und leitet bei Bedarf um.
// runGuardsAndResolvers: 'always': Die Guards werden auch
// neu ausgewertet, wenn wir erneut zur aktuellen Adresse "navigieren", was
// app.ts bei einer Änderung der Sitzung tut (Anmeldung, Abmeldung, Ablauf).
// ZUR ERINNERUNG: Diese Prüfungen sind nur eine BEQUEMLICHKEIT (keinen nutzlosen
// Bildschirm anzeigen). Der Schutz der Daten wird vom Server gewährleistet, der
// den Token und die Rolle bei JEDER Anfrage erneut prüft.
// =========================================================================

import { inject } from '@angular/core';
import { CanActivateFn, CanMatchFn, Router, Routes } from '@angular/router';
import { RdvMedecinsApi, PersonType } from './api/rdvmedecins-api';
import { Role } from './api/types';
import { Messages } from './state/messages';
import { homePage, Session } from './state/session';
import { keys } from './pages/persons-config';

// die Zugriffsrechte eines Bildschirms: öffentlich (ohne Anmeldung) oder bestimmten
// Rollen vorbehalten (fehlen die Rollen: alle angemeldeten Rollen)
interface Access {
  public: boolean;
  roles?: Role[];
}

export function accessOf(path: string): Access {
  if (path === '/login' || path === '/register') return { public: true };
  if (path.startsWith('/doctors') || path.startsWith('/clients')) return { public: false, roles: ['ADMIN'] };
  if (path === '/my-area' || path === '/my-account') return { public: false, roles: ['USER'] };
  if (path === '/schedule' || path === '/forbidden' || path === '/') return { public: false };
  return { public: true }; // unbekannte Adresse: die 404-Seite, für alle
}

// nur ein INTERNER Pfad ("/doctors"): niemals "//other-site.com"
export function internalPath(r: string | undefined): string | undefined {
  return r !== undefined && r.startsWith('/') && !r.startsWith('//') ? r : undefined;
}

// "3" -> 3; "", "abc", "-2", fehlend (undefined) -> undefined
export function positiveInteger(value: string | undefined): number | undefined {
  if (value === undefined || !/^\d+$/.test(value)) return undefined;
  const n = Number(value);
  return n > 0 ? n : undefined;
}

// der Guard ALLER Bildschirme
export const guard: CanActivateFn = async (_route, state) => {
  // zuerst inject(): Nach einem await befinden wir uns nicht mehr in einem Injektionskontext
  const session = inject(Session);
  const router = inject(Router);
  await session.check();
  const user = session.user();
  // state.url: die angeforderte Adresse samt Parametern ("/schedule?doctorId=1 ...")
  const url = router.parseUrl(state.url);
  const path = state.url.split(/[?#]/)[0];
  const access = accessOf(path);
  if (access.public) {
    // angemeldet: Der Anmeldebildschirm ergibt keinen Sinn mehr. Er wird HIER
    // verlassen, direkt nach der Anmeldung: Die Sitzung hat sich geändert, die Guards
    // werden neu ausgewertet. Wir gehen zum vor der Anmeldung angeforderten Bildschirm
    // (?redirect=...), sonst zur Startseite der Rolle
    if (path === '/login' && user !== null) {
      return router.parseUrl(internalPath(url.queryParams['redirect']) ?? homePage(user));
    }
    return true;
  }
  if (user === null) {
    // gewollte Abmeldung: der Anmeldebildschirm, ganz einfach
    if (session.voluntaryExit) return router.parseUrl('/login');
    // Sitzung abgelaufen, ohne Anmeldung geöffnete Adresse: Der angeforderte
    // Bildschirm wird gemerkt, um nach der Anmeldung dorthin zurückzukehren
    return router.createUrlTree(['/login'], { queryParams: { redirect: state.url } });
  }
  if (path === '/') return router.parseUrl(homePage(user));
  if (access.roles !== undefined && !access.roles.includes(user.role)) return router.parseUrl('/forbidden');
  // true: Die Navigation wird fortgesetzt; ein UrlTree: Es wird umgeleitet
  return true;
};

// ein Guard, der SPEZIFISCH für /register gilt: ohne Pass (CAPTCHA auf dem
// Anmeldebildschirm gelöst) zurück zum Anmeldebildschirm
const registrationGuard: CanActivateFn = async () => {
  const api = inject(RdvMedecinsApi);
  const messages = inject(Messages);
  const router = inject(Router);
  const valid = await api.registrationAccessStatus().catch(() => false);
  if (valid) return true;
  messages.flash({ success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT' });
  return router.parseUrl('/login');
};

// /doctors/abc/edit: Diese Route passt nicht ("match", canMatch);
// der Router probiert die folgenden, bis zur 404-Seite (**)
const validId: CanMatchFn = (_route, segments) => positiveInteger(segments[1]?.path) !== undefined;

// die drei Verwaltungsbildschirme der Ärzte ODER der Clients (ADMIN);
// data: feste Werte, die den Inputs der Komponente übergeben werden (type)
function personRoutes(type: PersonType): Routes {
  const c = keys(type);
  const list = () => import('./pages/persons').then((m) => m.PersonsPage);
  const form = () => import('./pages/person-form').then((m) => m.PersonFormPage);
  return [
    { path: type, title: c.title, data: { type }, loadComponent: list },
    { path: `${type}/add`, title: c.add, data: { type }, loadComponent: form },
    {
      path: `${type}/:id/edit`,
      title: c.edit,
      data: { type },
      canMatch: [validId],
      loadComponent: form,
    },
  ];
}

// die Bildschirme ohne ihre Guards; title: ein Übersetzungs-SCHLÜSSEL (siehe
// components/page-title.ts); loadComponent: Der Code des Bildschirms wird erst
// bei seinem ersten Besuch geladen (eine separate JavaScript-Datei)
const screens: Routes = [
  // "/": wird vom Guard immer umgeleitet (Startseite der Rolle oder Anmeldung)
  { path: '', pathMatch: 'full', children: [] },
  {
    path: 'login',
    title: 'LOGIN.TITLE',
    loadComponent: () => import('./pages/login').then((m) => m.LoginPage),
  },
  {
    path: 'schedule',
    title: 'SCHEDULE.PAGE_TITLE',
    loadComponent: () => import('./pages/schedule').then((m) => m.SchedulePage),
  },
  ...personRoutes('doctors'),
  ...personRoutes('clients'),
  {
    path: 'register',
    title: 'REGISTRATION.TITLE',
    canActivate: [registrationGuard],
    loadComponent: () => import('./pages/register').then((m) => m.RegisterPage),
  },
  {
    path: 'my-area',
    title: 'AREA.TITLE',
    loadComponent: () => import('./pages/patient-area').then((m) => m.PatientAreaPage),
  },
  {
    path: 'my-account',
    title: 'MY_ACCOUNT.TITLE',
    loadComponent: () => import('./pages/my-account').then((m) => m.MyAccountPage),
  },
  {
    path: 'forbidden',
    title: 'ERROR_PAGE.TITLE',
    data: { code: 403 },
    loadComponent: () => import('./pages/error-page').then((m) => m.ErrorPage),
  },
  // eine Adresse, die keine Route beschreibt: die 404-Seite
  {
    path: '**',
    title: 'ERROR_PAGE.TITLE',
    data: { code: 404 },
    loadComponent: () => import('./pages/error-page').then((m) => m.ErrorPage),
  },
];

// jeder Bildschirm erhält den gemeinsamen Guard (vor seinen eigenen Guards)
export const routes: Routes = screens.map((r) => ({
  ...r,
  canActivate: [guard, ...(r.canActivate ?? [])],
  runGuardsAndResolvers: 'always',
}));

Die Screens der Anwendung, ihre Adressen und ihre Zugriffsrechte (siehe Beispiele 17 und 18).

  • Zeilen 32–35: die Zugriffsrechte eines Screens: öffentlich oder auf bestimmte Rollen beschränkt (fehlt [roles] : alle Rollen);
  • Zeilen 37–43: die Berechtigungen für jede Adresse an EINER Stelle;
  • Zeilen 46–48: Der Adresse [?redirect=] wird nur gefolgt, wenn es sich um einen INTERNEN Pfad handelt: Im Web darf eine per E-Mail versendete Adresse [/login?redirect=//pirate-site.com] den Benutzer nach der Anmeldung nicht woandershin führen;
  • Zeilen 51–55: Die Parameter einer URL sind Zeichenketten, die (im Web) von jedem eingegeben werden können: „abc“ oder „-2“ werden zu [undefined];
  • Zeilen 58–89: DER Guard, der vor der Navigation zu jedem Screen ausgeführt wird (siehe Zeilen 176–180):
  • Zeile 62: Beim ersten Mal wird auf die Antwort des Servers auf die Frage „Wer ist angemeldet?“ gewartet; danach verursacht dieser Aufruf keine Kosten. Ein Guard kann asynchron sein ([async]): Der Router wartet auf seine Antwort;
  • Zeilen 65–67: [state.url]: die angeforderte Adresse einschließlich Parametern; [router.parseUrl]: die Zerlegung (ihr Pfad, ihre Parameter [queryParams]);
  • Zeilen 68–77: Ein öffentlicher Screen ist für alle zugänglich; ein angemeldeter Benutzer hat jedoch auf dem Anmeldescreen nichts verloren: Er gelangt zu dem Screen, den er vor der Anmeldung angefordert hatte, oder zur Startseite seiner Rolle. So verlässt die Anwendung den Anmeldescreen nach einer erfolgreichen Anmeldung: Der Anmeldescreen selbst muss nicht navigieren. Ein Guard, der einen [UrlTree] (eine analysierte Adresse) zurückgibt, LEITET die Navigation UM;
  • Zeilen 78–84: Niemand ist angemeldet: weiter zum Anmeldescreen. Nach Ablauf einer Sitzung oder wenn eine geschützte Adresse (im Web) direkt geöffnet wurde, wird der angeforderte Screen ([?redirect=]) gespeichert, um nach der Anmeldung dorthin zurückzukehren; nach einer beabsichtigten Abmeldung nicht. [createUrlTree] erstellt die Adresse und kodiert dabei den Parameter;
  • Zeilen 85–88: [/] führt zur Startseite der Rolle; ist die Rolle unzureichend, führt es zu einer 403-Seite; andernfalls [true]: Die Navigation wird fortgesetzt;
  • Zeilen 93–101: Ein für einen Pfad SPEZIFISCHER Guard: Die Kontoerstellung erfordert einen Passierschein, den der Server ausstellt, sobald das CAPTCHA eingegeben wurde ([POST /api/register/access], siehe Anmeldescreen). Ohne ihn wird der Benutzer mit einer Meldung zum Anmeldescreen zurückgeschickt;
  • Zeile 105: Ein Guard vom Typ [CanMatchFn] prüft nicht, ob Sie das RECHT haben, zu einem Screen zu gelangen, sondern ob die Route zur Adresse PASST: [/doctors/abc/edit] passt nicht zur Route [doctors/:id/edit]; der Router probiert die folgenden Routen aus, bis er bei der 404-Seite ankommt;
  • Zeilen 109–124: eine Funktion, die die drei Routen für die Ärzte ODER die Clients erzeugt: [/doctors], [/doctors/add], [/doctors/:id/edit]. [:id]: ein Pfadparameter, der an den Input [id] der Komponente übergeben wird; [data: { type }]: ein fester Wert, der an ihren Input [type] übergeben wird. [title]: der Titel des Screens (ein Übersetzungsschlüssel; siehe [page-title.ts]);
  • Zeilen 111–112: [loadComponent]: Der Code eines Screens wird erst beim ersten Besuch geladen. [import()] lädt ein Modul bei Bedarf; [ng build] legt daher jeden Screen in einer eigenen [JavaScript]-Datei ab, und die Anwendung startet schneller;
  • Zeile 131: [/]: eine Route ohne Screen ([children: []]), die vom Guard immer umgeleitet wird;
  • Zeilen 132–136: [/login?login=jbernard] (nach der Erstellung eines Kontos) füllt das Anmeldefeld vor: Der Parameter [login] wird dem gleichnamigen Input des Anmeldescreens zugewiesen;
  • Zeilen 137–141: Ebenso werden die drei Kalenderparameter ([doctorId], [day], [book]) den Feldern des Screens zugewiesen: Der gesamte Zustand des Screens steckt in der Adresse (siehe [schedule.ts]);
  • Zeilen 160–172: Seite 403 und, für jede Adresse, die von keiner Route beschrieben wird (der „Wildcard“-Pfad, zwei Sternchen), Seite 404: derselbe Screen mit einem anderen Code ([data]);
  • Zeilen 176–180: Jede Route erhält den gemeinsamen Guard vor ihren eigenen Guards. [runGuardsAndResolvers: 'always']: Die Guards werden bei jeder Navigation ausgeführt, auch zur aktuellen Adresse (standardmäßig nur, wenn sich der Pfad oder seine Parameter ändern). Dadurch kann [app.ts] sie neu auswerten, wenn sich die Sitzung ändert.

Diese Prüfungen dienen lediglich der BEQUEMLICHKEIT: Sie verhindern, dass ein unnötiger Screen angezeigt wird. Der Schutz der Daten wird vom Server gewährleistet, der Token und Rolle bei jeder Anfrage erneut überprüft.

11.12. Die Komponenten

11.12.1. src/app/components/layout.ts

// =========================================================================
// src/app/components/layout.ts - das für alle Bildschirme GEMEINSAME LAYOUT
// -------------------------------------------------------------------------
// Die einzige Komponente der Root-Komponente (siehe app.ts); sie umgibt
// den Platz der Bildschirme (<ion-router-outlet>):
//   - die obere Leiste: Titel, Sprache (FR / EN), Abmeldung;
//   - das seitliche Menü ("Drawer", <ion-menu>), geöffnet über die Schaltfläche ☰: die
//     für die Rolle des Benutzers erlaubten Bildschirme. "Ärzte" und "Patienten"
//     erscheinen nur für den ADMIN: eine bloße Anzeigebequemlichkeit, der
//     eigentliche Schutz ist der des Servers;
//   - eine Erfolgsmeldung OBEN;
//   - der aktuelle Bildschirm (<ion-router-outlet>);
//   - der Fehlerbereich UNTEN.
// Auf einem großen Bildschirm (Web, Tablet) wird das Menü dauerhaft
// links angezeigt: Das ist die Aufgabe von <ion-split-pane>.
// =========================================================================

import { Component, computed, inject, signal } from '@angular/core';
import { toSignal } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router, RouterLink } from '@angular/router';
import {
  IonButton, IonButtons, IonChip, IonContent, IonFooter, IonHeader, IonIcon, IonItem, IonLabel, IonList,
  IonMenu, IonMenuButton, IonMenuToggle, IonPopover, IonRouterLink, IonRouterOutlet, IonSplitPane, IonTitle,
  IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import {
  calendar, checkmarkCircle, close, alertCircle, home, logOutOutline, medkit, people, personCircle,
} from 'ionicons/icons';
import { filter, map } from 'rxjs';
import { User } from '../api/types';
import { Messages } from '../state/messages';
import { isAdmin, isPatient, Session } from '../state/session';
import { Language, languages, Translations } from '../i18n/translations';

// ein Menüeintrag: Pfad, Schlüssel der Beschriftung, Symbol
interface MenuEntry {
  path: string;
  key: string;
  icon: string;
}

export function menuEntries(u: User | null): MenuEntry[] {
  if (u === null) return [];
  return [
    ...(isPatient(u) ? [{ path: '/my-area', key: 'APP.MENU_MY_AREA', icon: 'home' }] : []),
    { path: '/schedule', key: 'APP.MENU_SCHEDULE', icon: 'calendar' },
    ...(isAdmin(u)
      ? [
          { path: '/doctors', key: 'APP.MENU_DOCTORS', icon: 'medkit' },
          { path: '/clients', key: 'APP.MENU_PATIENTS', icon: 'people' },
        ]
      : []),
    ...(isPatient(u) ? [{ path: '/my-account', key: 'APP.MENU_ACCOUNT', icon: 'person-circle' }] : []),
  ];
}

@Component({
  selector: 'app-layout',
  imports: [
    RouterLink, IonRouterLink, IonSplitPane, IonMenu, IonMenuToggle, IonMenuButton, IonHeader, IonToolbar, IonTitle,
    IonButtons, IonButton, IonIcon, IonContent, IonList, IonItem, IonLabel, IonChip, IonPopover, IonRouterOutlet,
    IonFooter,
  ],
  templateUrl: './layout.html',
  styleUrl: './layout.scss',
})
export class Layout {
  private readonly session = inject(Session);
  private readonly translations = inject(Translations);
  readonly messages = inject(Messages);
  readonly t = this.translations.t;
  readonly language = this.translations.language;
  readonly languages = languages;
  readonly user = this.session.user;
  readonly entries = computed(() => menuEntries(this.user()));

  // die aktuelle Adresse ohne ihre Parameter: ein aus den Ereignissen
  // des Routers erzeugtes Signal (toSignal: Observable -> Signal)
  private readonly path = toSignal(
    inject(Router).events.pipe(
      filter((e) => e instanceof NavigationEnd),
      map((e) => e.urlAfterRedirects.split('?')[0]),
    ),
    { initialValue: '' },
  );
  // das Sprachmenü: geöffnet oder nicht, und unter welchem Element
  readonly languagesOpen = signal(false);
  languagesEvent?: Event;

  constructor() {
    addIcons({ calendar, checkmarkCircle, close, alertCircle, home, logOutOutline, medkit, people, personCircle });
  }

  // der Menüeintrag des aktuellen Bildschirms
  isActive(e: MenuEntry): boolean {
    return this.path().startsWith(e.path);
  }

  // die Sprachschaltfläche: Das Sprachmenü öffnet sich unter ihr
  openLanguages(event: Event): void {
    this.languagesEvent = event;
    this.languagesOpen.set(true);
  }

  // FR / EN: keine Anfrage an den Server, der Bildschirm wird auf der Stelle neu übersetzt
  changeLanguage(l: Language): void {
    void this.translations.changeLanguage(l);
  }

  // die Sitzung wird geleert; die Router-Guards, neu ausgewertet, zeigen
  // den Anmeldebildschirm an. catch: auch wenn der Server nicht antwortet
  logOut(): void {
    this.session.logOut().catch(() => undefined);
  }
}

Die Komponente, die alle Screens umgibt: die obere Leiste, das Menü und die Meldungen. Sie ist das Gegenstück zum Widget [ShellRoute] im [Flutter]-Client.

  • Zeilen 37–41: ein Menüeintrag: ein Interface;
  • Zeilen 43–56: die Menüeinträge, die für die Rolle des Benutzers zulässig sind. [...(condition ? [entries] : [])]: Der Spread-Operator fügt null, einen oder mehrere Einträge in das Array ein ([if] in einer Liste von [Dart]);
  • Zeilen 69–76: die Services und das, was das Template anzeigt: die Sprache, der Benutzer, die Menüeinträge (ein berechneter Wert: Er ändert sich je nach Benutzer);
  • Zeilen 80–86: die aktuelle Adresse, um den aktiven Menüeintrag zu markieren. [toSignal] wandelt ein [Observable] (die Router-Ereignisse, für die Navigation reduziert) in ein vom Template lesbares Signal um; es muss ein Anfangswert angegeben werden;
  • Zeilen 88–89: das Sprachmenü: geöffnet oder geschlossen, und das Ereignis (Tippen auf die Schaltfläche), das es öffnet;
  • Zeile 92: die vom Template verwendeten Icons, registriert mit [ionicons];
  • Zeilen 107–109: Sprache wechseln: Es wird keine Anfrage an den Server gesendet; das Wörterbuch ändert sich, und alles, was eine Übersetzung anzeigt, wird aktualisiert;
  • Zeilen 113–115: Abmeldung: Die Sitzung wird geleert, und die erneut ausgewerteten Guards (siehe [app.ts]) zeigen den Anmeldescreen an. [catch]: Selbst wenn der Server nicht antwortet, gilt der Benutzer als abgemeldet.

11.12.2. src/app/components/layout.html

<!-- ======================================================================
     layout.html - das allen Bildschirmen gemeinsame Layout
     ====================================================================== -->

<!-- ion-split-pane: Ab 800 Pixeln Breite (when) wird das Menü
     dauerhaft links vom Inhalt angezeigt; darunter ist es ein Drawer.
     contentId: die Kennung des Hauptinhalts. disabled: kein Menü
     für einen nicht angemeldeten Besucher -->
<ion-split-pane contentId="main" when="(min-width: 800px)" [disabled]="!user()">
  <ion-menu contentId="main" [disabled]="!user()">
    <ion-content>
      @if (user(); as u) {
        <!-- der Kopf des Menüs: wer angemeldet ist -->
        <div class="who">
          <div class="name">{{ u.name }}</div>
          <ion-chip [outline]="true">{{ u.role }}</ion-chip>
        </div>
        <ion-list lines="none">
          @for (e of entries(); track e.path) {
            <!-- ion-menu-toggle: Das Berühren des Eintrags schließt den Drawer;
                 routerDirection="root": Der gewählte Bildschirm ersetzt den gesamten
                 Bildschirmstapel (kein Zurück zum vorherigen Bildschirm) -->
            <ion-menu-toggle [autoHide]="false">
              <ion-item
                [button]="true"
                [detail]="false"
                [routerLink]="e.path"
                routerDirection="root"
                [class.active]="isActive(e)"
              >
                <ion-icon slot="start" [name]="e.icon" />
                <ion-label>{{ t(e.key) }}</ion-label>
              </ion-item>
            </ion-menu-toggle>
          }
        </ion-list>
      }
    </ion-content>
  </ion-menu>

  <!-- der Hauptinhalt: eine Ionic-"Seite" (Klasse ion-page: in einer Spalte,
       über die volle Höhe) -->
  <div class="ion-page" id="main">
    <ion-header>
      <ion-toolbar color="primary">
        <!-- ion-menu-button: die Schaltfläche ☰, die den Drawer öffnet. Sie versteckt
             sich, wenn das Menü deaktiviert oder dauerhaft angezeigt ist -->
        <ion-buttons slot="start">
          <ion-menu-button />
        </ion-buttons>
        <ion-title>{{ t('APP.TITLE') }}</ion-title>
        <ion-buttons slot="end">
          <!-- die Sprachschaltfläche öffnet das unten deklarierte Popover -->
          <ion-button id="language-button" [title]="t('APP.LANGUAGE')" (click)="openLanguages($event)">
            <strong>{{ language().toUpperCase() }}</strong>
          </ion-button>
          @if (user()) {
            <ion-button [title]="t('APP.LOGOUT')" (click)="logOut()">
              <ion-icon slot="icon-only" name="log-out-outline" />
            </ion-button>
          }
        </ion-buttons>
      </ion-toolbar>
    </ion-header>

    <!-- ion-popover: ein kleines Fenster, das (isOpen) unter dem berührten Element
         (event) geöffnet wird; dismissOnSelect: es schließt sich bei einer Auswahl;
         didDismiss: es wurde geschlossen (Auswahl oder Tippen daneben) -->
    <ion-popover
      [isOpen]="languagesOpen()"
      [event]="languagesEvent"
      [dismissOnSelect]="true"
      (didDismiss)="languagesOpen.set(false)"
    >
      <ng-template>
        <ion-list lines="none">
          @for (l of languages; track l) {
            <ion-item [button]="true" [detail]="false" (click)="changeLanguage(l)">
              <ion-label>{{ l.toUpperCase() }}</ion-label>
            </ion-item>
          }
        </ion-list>
      </ng-template>
    </ion-popover>

    <!-- die Erfolgsmeldung oben -->
    @if (messages.success(); as success) {
      <ion-item class="message success" lines="none">
        <ion-icon slot="start" name="checkmark-circle" />
        <ion-label class="ion-text-wrap">{{ t(success.key, success.params) }}</ion-label>
        <ion-button slot="end" fill="clear" color="dark" (click)="messages.clear()">
          <ion-icon slot="icon-only" name="close" />
        </ion-button>
      </ion-item>
    }

    <!-- der aktuelle Bildschirm -->
    <div class="screen">
      <ion-router-outlet />
    </div>

    <!-- der Fehlerbereich unten: immer sichtbar, auch wenn der Bildschirm scrollt.
         ion-footer: oberhalb der Navigationsleiste des Telefons -->
    @if (messages.error(); as error) {
      <ion-footer>
        <ion-item class="message error" lines="none">
          <ion-icon slot="start" name="alert-circle" />
          <ion-label class="ion-text-wrap">{{ t(error.key, error.params) }}</ion-label>
          <ion-button slot="end" fill="clear" color="dark" (click)="messages.clear()">
            <ion-icon slot="icon-only" name="close" />
          </ion-button>
        </ion-item>
      </ion-footer>
    }
  </div>
</ion-split-pane>
  • Zeile 9: [ion-split-pane]: Auf einem großen Bildschirm (hier breiter als 800 Pixel: [when], eine CSS-„Media Query“) wird das Menü DAUERHAFT links vom Inhalt angezeigt; auf einem kleinen Bildschirm ist es eine Schublade, die mit der Schaltfläche ☰ geöffnet wird. Das Layout von [Flutter] – hier von [Ionic] selbst erzeugt – traf die Wahl zwischen [NavigationDrawer] und [NavigationRail]. [contentId]: der Bezeichner des Hauptinhalts (Zeile 43). Kein Menü für einen Besucher, der nicht angemeldet ist ([disabled]);
  • Zeilen 10–39: [ion-menu]: das Menü; oben, für angemeldete Benutzer (der Name und die Rolle in einem „Chip“, [ion-chip]);
  • Zeilen 23–34: ein Menüeintrag. [ion-menu-toggle] schließt die Schublade, wenn auf den Eintrag getippt wird ([autoHide] auf [false]: Der Eintrag bleibt sichtbar, wenn das Menü dauerhaft angezeigt wird). [routerLink]: die Adresse des Screens (siehe Beispiel 17); [routerDirection="root"]: Der gewählte Screen ERSETZT den gesamten Screen-Stapel von [Ionic]: Die Zurück-Schaltfläche führt nicht zum vorherigen Screen (wie bei [context.go] und [go_router]). [class.active]: Die CSS-Klasse [active] wird auf den Eintrag des aktuellen Screens gesetzt;
  • Zeile 43: der Hauptinhalt: eine „Seite“ von [Ionic] (Klasse [ion-page]: in einer Spalte, über die gesamte Höhe);
  • Zeilen 44–64: die obere Leiste: die Schaltfläche ☰ ([ion-menu-button], die sich automatisch ausblendet, wenn das Menü deaktiviert ist oder dauerhaft angezeigt wird), der Titel, die Sprachschaltfläche (ihr Text, „FR“ oder „EN“) und die Abmeldeschaltfläche (nur für einen angemeldeten Benutzer);
  • Zeilen 69–84: [ion-popover]: ein kleines Fenster, geöffnet ([isOpen]) unterhalb des angetippten Elements ([event]), das sich schließt, wenn ([dismissOnSelect]); [didDismiss]: Es wurde geschlossen, entweder durch eine Auswahl oder durch Tippen daneben. Sein Inhalt steht in einem [ng-template]: Er wird erst beim Öffnen erzeugt;
  • Zeilen 87–95: die Erfolgsmeldung oben, sofern vorhanden. [@if (messages.success(); as success)]: die Bedingung und ihr Wert, gespeichert in einer Template-Variablen;
  • Zeilen 98–100: Der Platz für die Screens, [ion-router-outlet] (siehe Beispiel 17): Der Router zeigt dort den Screen für die aktuelle Adresse an. Der Screen mit der Bezeichnung [Ionic] verwaltet den Übergang zwischen Screens und hält die vorherigen Screens verborgen im Speicher: Die Zurück-Schaltfläche führt zu ihnen zurück, ohne sie neu zu erzeugen;
  • Zeilen 104–114: der Fehlerbereich unten: [ion-footer], der auch beim Scrollen des Screens sichtbar bleibt und oberhalb der Navigationsleiste des Telefons positioniert ist.

11.12.3. src/app/components/layout.scss

// =========================================================================
// layout.scss - die Stile des Layouts
// =========================================================================

// der Kopf des Menüs. Auf dem Telefon reicht der Drawer unter die Statusleiste von
// Android (Uhrzeit, Akku): Ihre Höhe wird oben hinzugefügt
.who {
  padding: calc(16px + var(--ion-safe-area-top, 0px)) 16px 8px 20px;

  .name {
    font-size: 18px;
    font-weight: 500;
  }
}

// der Menüeintrag des aktuellen Bildschirms: auf farbigem, abgerundetem Hintergrund
ion-item.active {
  --background: rgba(var(--ion-color-primary-rgb), 0.14);
  --border-radius: 28px;
  margin: 0 8px;
  font-weight: 500;
}

ion-menu-toggle ion-item {
  margin: 0 8px;
}

// auf einem großen Bildschirm: die Breite des dauerhaft angezeigten Menüs
ion-split-pane {
  --side-width: 230px;
  --side-min-width: 230px;
  --side-max-width: 230px;
}

// der Platz der Bildschirme: die gesamte verbleibende Höhe. <ion-router-outlet>
// ist "absolute" positioniert: Es füllt diesen "relative"-Container
.screen {
  position: relative;
  flex: 1;
}

// die Meldungsbanner
.message {
  font-size: 17px;
}

.success {
  --background: #e8f5e9;
  --color: #1b5e20;

  ion-icon[slot='start'] {
    color: #388e3c;
  }
}

.error {
  --background: #f8d7da;
  --color: #b71c1c;

  ion-icon[slot='start'] {
    color: #c62828;
  }
}

Die Stile des Layouts. Sie gelten nur für Elemente von [layout.html]: [Angular] „kapselt“ die Stile einer Komponente.

  • Zeilen 7–8: der Kopf des Menüs (der Name und die Rolle des Benutzers). Auf dem Telefon nimmt die App den gesamten Bildschirm ein, einschließlich der oberen Leiste, in der [Android] die Uhrzeit und den Akkustand anzeigt (die Statusleiste): Die Toolbar von [Ionic] ([ion-toolbar]) passt ihre Position automatisch an, dieses einfache [div] jedoch nicht. Die CSS-Variable [--ion-safe-area-top], bereitgestellt von [Ionic], gibt die Höhe dieser Leiste an (0 in einem Browser): Sie wird zum oberen Rand addiert. Ohne sie überlappt der Name die Uhrzeit;
  • Zeilen 17–22: der aktive Menüeintrag auf farbigem, abgerundetem Hintergrund, wie in einem [Material]-3-Menü. [rgba(var(--ion-color-primary-rgb), 0.14)]: die Hauptfarbe, fast transparent;
  • Zeilen 29–33: die Breite des dauerhaft angezeigten Menüs (sonst 270 Pixel);
  • Zeilen 37–40: [ion-router-outlet] wird auf „absolute“ gesetzt (es füllt sein übergeordnetes Element): Es wird in einen Container platziert, der die gesamte verbleibende Höhe einnimmt ([flex: 1]), zwischen den Meldungen;
  • Zeilen 47–63: die Meldungsbanner: grün für Erfolg, rosa für einen Fehler und die Farben der übrigen Clients.

11.12.4. src/app/components/page-title.ts

// =========================================================================
// src/app/components/page-title.ts - der Titel des Bildschirms, übersetzt
// -------------------------------------------------------------------------
// Im Web: der Titel des Tabs; unter Android: der Name der Anwendung
// in der Liste der zuletzt verwendeten Anwendungen. "Terminkalender - RdvMedecins"
//
// Der Router von Angular kann jedem Bildschirm einen Titel geben: die
// Eigenschaft title einer Route (siehe app.routes.ts). Nach jeder Navigation ruft er
// die "Title Strategy" (TitleStrategy) auf. Wir ersetzen die von Angular
// (siehe main.ts) durch diese: Unsere Titel sind
// Übersetzungs-SCHLÜSSEL, und der Titel muss sich auch bei einem Sprachwechsel ändern.
// =========================================================================

import { effect, inject, Injectable, signal } from '@angular/core';
import { Title } from '@angular/platform-browser';
import { RouterStateSnapshot, TitleStrategy } from '@angular/router';
import { Translations } from '../i18n/translations';

@Injectable()
export class PageTitle extends TitleStrategy {
  private readonly title = inject(Title);
  private readonly t = inject(Translations).t;
  // der Schlüssel des Titels des aktuellen Bildschirms
  private readonly key = signal<string | undefined>(undefined);

  constructor() {
    super();
    // erneut ausgeführt, wenn sich der Schlüssel ändert (Navigation) ODER wenn sich die Sprache ändert
    // (t liest das Wörterbuch, ein Signal)
    effect(() => {
      const key = this.key();
      const application = this.t('APP.TITLE');
      this.title.setTitle(key ? `${this.t(key)} - ${application}` : application);
    });
  }

  // vom Router nach jeder Navigation aufgerufen; buildTitle: die
  // Eigenschaft title der angezeigten Route
  override updateTitle(state: RouterStateSnapshot): void {
    this.key.set(this.buildTitle(state));
  }
}

Der Titel des Screens, übersetzt: der Dokumenttitel, der Tab-Titel im Web. Der [Angular]-Router kann jedem Screen einen Titel zuweisen: die Eigenschaft [title] seiner Route (siehe [app.routes.ts]); nach jeder Navigation ruft er die „Titelstrategie“ ([TitleStrategy]) auf, die [main.ts] durch diese ersetzt.

  • Zeile 19: [@Injectable()] ohne [providedIn]: Der Service wird von [main.ts] bereitgestellt, statt von dem von [Angular];
  • Zeilen 30–34: Ein Effekt, der erneut ausgeführt wird, wenn sich der Titelschlüssel ändert (ein Navigationsereignis) ODER wenn sich die Sprache ändert ([t] liest das Wörterbuch, ein Signal). [Title]: der Service von [Angular] , der den Seitentitel schreibt;
  • Zeilen 39–41: wird vom Router nach jeder Navigation aufgerufen; [buildTitle] legt die Eigenschaft [title] der angezeigten Route fest.

Der [Flutter]-Client umschließt jeden Screen mit einem Widget [PageTitle]; hier werden die Titel zusammen mit den Routen deklariert.

11.12.5. src/app/components/form-submission.ts

// =========================================================================
// src/app/components/form-submission.ts - Senden eines Formulars an den Server
// -------------------------------------------------------------------------
// Alle Formulare der Anwendung folgen demselben Muster wie
// Beispiel 25: Auf dem Telefon wird keine Regel geprüft (sie leben
// an EINER einzigen Stelle, dem Server), und bei einer Ablehnung:
//   - wird der Fehler jedes Felds (ApiError.fields) unter dem Feld angezeigt;
//   - wird die allgemeine Meldung (ApiError.key) unten am Bildschirm angezeigt.
// Diese Klasse fasst diese Schritte zusammen. Sie ist kein Service: Ein Bildschirm
// erzeugt pro Formular eine (new), mit eigenen Signals:
//
//     readonly submission = new FormSubmission(inject(Messages));
//     if (await this.submission.submit(() => api.register(form))) { ... }
//     <app-input-field ... [error]="submission.errors()['lastName']" />
// =========================================================================

import { signal } from '@angular/core';
import { ApiError, Texts } from '../api/api-error';
import { Messages } from '../state/messages';

export class FormSubmission {
  // der Fehler jedes Felds: ein Übersetzungs-SCHLÜSSEL
  readonly errors = signal<Texts>({});
  // die Parameter der Fehlermeldungen ({{min}} ...), vom Server zurückgesendet
  readonly params = signal<Texts>({});
  readonly inProgress = signal(false);

  constructor(private readonly messages: Messages) {}

  // führt das Senden aus; liefert true, wenn es gelungen ist. Bei einem ApiError
  // werden die Fehler angezeigt und false zurückgegeben
  async submit(action: () => Promise<unknown>): Promise<boolean> {
    if (this.inProgress()) return false; // keine doppelte Übermittlung
    this.errors.set({});
    this.params.set({});
    this.inProgress.set(true);
    try {
      await action();
      return true;
    } catch (e) {
      // jeder andere Fehler ist eine Anomalie: showApiError wirft ihn erneut
      this.messages.showApiError(e);
      const error = e as ApiError;
      this.errors.set(error.fields);
      this.params.set(error.params);
      return false;
    } finally {
      this.inProgress.set(false);
    }
  }

  // der Benutzer ändert ein Feld: Sein Fehler verschwindet
  clearError(field: string): void {
    if (field in this.errors()) {
      // ein NEUES Objekt, ohne dieses Feld: Das Signal ändert seinen Wert
      const { [field]: _removed, ...others } = this.errors();
      this.errors.set(others);
    }
  }
}

Absenden eines Formulars an den Server: das [Command] aus Beispiel 23, ergänzt um Feldfehler (Beispiel 25). Dies ist kein Service: Jedes Formular erzeugt sein eigenes ([new]) mit eigenen Signalen.

  • Zeilen 23–26: der Fehler für jedes Feld (ein Übersetzungsschlüssel), die Meldungsparameter und das laufende Absenden (die Schaltflächen werden deaktiviert). Drei Signale, die die Templates lesen;
  • Zeile 28: [private readonly messages]: ein Konstruktorparameter, der zu einer Eigenschaft wird (siehe [api-error.ts]);
  • Zeilen 32–50: das Absenden: keine doppelten Übermittlungen; tritt ein [ApiError] auf, werden die allgemeine Meldung unten auf dem Bildschirm und der Fehler für jedes Feld angezeigt. [finally] läuft in allen Fällen, auch nach einem [return];
  • Zeilen 53–59: Der Benutzer korrigiert ein Feld; der Fehler verschwindet. Es wird ein NEUES Objekt ohne dieses Feld erzeugt ([const { [field]: _removed, ...others } = ...]: eine Destrukturierungszuweisung, deren Rest [others] alle Felder außer diesem enthält): Ein Signal benachrichtigt seine Beobachter nur, wenn sich sein Wert ändert, und eine Änderung des Objekts selbst würde ihn nicht ändern.

11.12.6. src/app/components/input-field.ts

// =========================================================================
// src/app/components/input-field.ts - ein vollständiges Formularfeld
// -------------------------------------------------------------------------
// Beschriftung + Feld + Hilfemeldung ODER Fehlermeldung. Alle
// Formulare der Anwendung verwenden es:
//
//   <app-input-field label="PERSONS.LASTNAME_LABEL" [maxLength]="20"
//       [value]="form().lastName" (valueChange)="update('lastName', $event)"
//       [error]="submission.errors()['lastName']" />
//
// Es ist eine GESTEUERTE Komponente (siehe Beispiel 11): Der Wert gehört dem
// Eltern-Formular, das ihn übergibt (Input value) und bei
// jedem Tastenanschlag zurückerhält (Output valueChange). label, help und error sind
// Übersetzungs-SCHLÜSSEL; params, die Parameter ihrer Meldungen ({{min}} ...).
// =========================================================================

import { Component, inject, input, output } from '@angular/core';
import { InputCustomEvent, IonInput } from '@ionic/angular';
import type { AutocompleteTypes } from '@ionic/core';
import { Texts } from '../api/api-error';
import { Translations } from '../i18n/translations';

@Component({
  selector: 'app-input-field',
  imports: [IonInput],
  templateUrl: './input-field.html',
  styles: `
    :host {
      display: block;
      margin-bottom: 8px;
    }
  `,
})
export class InputField {
  readonly t = inject(Translations).t;

  // input.required: ein Pflicht-Input (Kompilierfehler, wenn das Elternelement ihn vergisst)
  readonly label = input.required<string>();
  readonly value = input.required<string>();
  readonly error = input<string>();
  readonly help = input<string>();
  readonly params = input<Texts>({});
  readonly secret = input(false); // ein Passwort: verborgene Zeichen
  readonly maxLength = input<number>();
  // für den Passwortmanager des Telefons ('username', 'current-password' ...)
  readonly autocomplete = input<AutocompleteTypes>('off');

  readonly valueChange = output<string>();

  // ionInput: bei jedem Tastenanschlag (ionChange: nur, wenn das Feld den Fokus verliert)
  change(event: InputCustomEvent): void {
    this.valueChange.emit(event.detail.value ?? '');
  }
}

Ein vollständiges Formularfeld: Label, Feld, Hilfetext oder Fehlermeldung. Alle Formulare verwenden es.

  • Zeilen 38–46: die Inputs (siehe Beispiel 10). Das Label, der Hilfetext und die Fehlermeldung sind Übersetzungsschlüssel. [input.required]: ein erforderlicher Input; wird er vom übergeordneten Element weggelassen, führt das zu einem Kompilierfehler. [AutocompleteTypes]: der von [Ionic] bereitgestellte Typ der zulässigen Werte für das HTML-Attribut [autocomplete];
  • Zeile 48: der Output (siehe Beispiel 11): der neue Wert bei jedem Tastenanschlag. Eine GESTEUERTE Komponente: Der Wert gehört dem übergeordneten Element, das ihn bereitstellt ([value]) und ihn empfängt ([valueChange]). Ändert das übergeordnete Element ihn selbst (das CAPTCHA wird nach einem Fehlschlag geleert), folgt das Feld: Es ist nichts zu schreiben, anders als beim [didUpdateWidget] des Clients aus [Flutter];
  • Zeilen 51–53: [ionInput]: das Ereignis von [ion-input] bei jedem Tastenanschlag ([ionChange] tritt nur auf, wenn das Feld den Fokus verliert); [detail.value] kann [null] oder [undefined] sein: In diesem Fall wird eine leere Zeichenkette gesendet.

11.12.7. src/app/components/input-field.html

<!-- ======================================================================
     input-field.html - das Template eines Formularfelds
     ====================================================================== -->

<!-- fill="outline": ein umrahmtes Feld; labelPlacement="floating": das
     Label steht im leeren Feld und "schwebt" auf den Rahmen, sobald das Feld
     den Fokus oder einen Wert hat;
     helperText / errorText: die Meldungen unter dem Feld. errorText wird nur
     angezeigt (in Rot, anstelle der Hilfe), wenn das Feld die
     Klassen ion-invalid UND ion-touched hat -->
<ion-input
  [label]="t(label())"
  fill="outline"
  labelPlacement="floating"
  [type]="secret() ? 'password' : 'text'"
  [value]="value()"
  [maxlength]="maxLength()"
  [autocomplete]="autocomplete()"
  [autocorrect]="secret() ? 'off' : 'on'"
  [helperText]="help() ? t(help()!, params()) : undefined"
  [errorText]="error() ? t(error()!, params()) : undefined"
  [class.ion-invalid]="!!error()"
  [class.ion-touched]="!!error()"
  (ionInput)="change($event)"
/>
  • Zeilen 13–14: ein umrahmtes Feld ([fill="outline"]), dessen Label im leeren Feld steht und über dem Rahmen „schwebt“, sobald es den Fokus oder einen Wert hat;
  • Zeile 15: Ein Passwort wird verborgen;
  • Zeilen 17–19: [maxlength] beschränkt die Eingabe; [autocomplete] teilt dem Passwortmanager des Telefons mit, was das Feld enthält (einen Benutzernamen, ein Passwort oder ein neues Passwort); die Rechtschreibprüfung prüft keine Passwörter;
  • Zeilen 20–23: Hilfe- und Fehlermeldungen erscheinen unterhalb des Felds. [ion-input] zeigt den Fehler (in Rot, anstelle des Hilfetexts) nur an, wenn das Feld die CSS-Klassen [ion-invalid], und [ion-touched] besitzt: Diese werden gesetzt, wenn ein Fehler vorliegt. Normalerweise werden diese Klassen von den [Angular]-Formularen gesetzt (Beispiel 08); hier bestimmt der SERVER die Gültigkeit. Wovon die Beispiele 07 und 11 abgeraten haben (diese Klassen manuell zu setzen), funktioniert hier: [Ionic] entfernt sie zwar beim nächsten Tastenanschlag, aber dieser Tastenanschlag löscht auch den Fehler ([clearError]), der nicht mehr angezeigt werden soll;
  • Zeile 24: Jeder Tastenanschlag ruft [change] auf.

11.12.8. src/app/components/person-fields.ts

// =========================================================================
// src/app/components/person-fields.ts - Titel, Vorname, Nachname
// -------------------------------------------------------------------------
// Die Identitätsfelder, gemeinsam für drei Formulare: Arzt / Client des
// ADMIN, "Patientenkonto anlegen" und "Mein Konto verwalten". Das Elternelement
// übergibt ihm die Werte, die Fehler und erhält jede Änderung:
//     <app-person-fields [values]="form()" [errors]="submission.errors()"
//         (fieldChange)="update($event.field, $event.value)" />
// =========================================================================

import { Component, inject, input, output } from '@angular/core';
import { IonSelect, IonSelectOption, SelectCustomEvent } from '@ionic/angular';
import { Texts } from '../api/api-error';
import { Data } from '../api/rdvmedecins-api';
import { Translations } from '../i18n/translations';
import { InputField } from './input-field';

export const titles = ['Mr', 'Mme', 'Melle'];

export interface FieldChange {
  field: string;
  value: string;
}

@Component({
  selector: 'app-person-fields',
  imports: [IonSelect, IonSelectOption, InputField],
  templateUrl: './person-fields.html',
})
export class PersonFields {
  readonly t = inject(Translations).t;
  readonly titles = titles;

  readonly values = input.required<Data>();
  readonly errors = input.required<Texts>();
  readonly fieldChange = output<FieldChange>();

  // der Wert eines Felds, als Text
  value(field: string): string {
    return String(this.values()[field] ?? '');
  }

  update(field: string, value: string): void {
    this.fieldChange.emit({ field, value });
  }

  chooseTitle(event: SelectCustomEvent<string>): void {
    this.update('title', event.detail.value);
  }
}

Die Identitätsfelder (Anrede, Vorname, Nachname), die den ADMIN-Formularen, dem Formular zur Kontoerstellung und dem Formular „Mein Konto verwalten“ gemeinsam sind.

  • Zeilen 34–36: Das übergeordnete Element übergibt die Werte und Fehler und empfängt EINEN Output für jedes Feld: seinen Namen und seinen neuen Wert;
  • Zeilen 39–41: der Wert eines Felds als Text (Formularwerte haben den Typ [unknown]);
  • Zeilen 47–49: die aus der Liste ausgewählte Anrede; [SelectCustomEvent<string>]: das Ereignis von [ion-select], dessen Wert ein Text ist.

11.12.9. src/app/components/person-fields.html

<!-- ======================================================================
     person-fields.html - Anrede, Vorname, Nachname
     ====================================================================== -->

<!-- ion-select: eine Dropdown-Liste mit Label und Fehlermeldung;
     interface="popover": die Liste öffnet sich unter dem Feld -->
<ion-select
  [label]="t('PERSONS.TITLE_LABEL')"
  fill="outline"
  labelPlacement="floating"
  interface="popover"
  [value]="value('title')"
  [errorText]="errors()['title'] ? t(errors()['title']) : undefined"
  [class.ion-invalid]="!!errors()['title']"
  [class.ion-touched]="!!errors()['title']"
  (ionChange)="chooseTitle($event)"
>
  @for (title of titles; track title) {
    <ion-select-option [value]="title">{{ title }}</ion-select-option>
  }
</ion-select>

<app-input-field
  label="PERSONS.FIRSTNAME_LABEL"
  [maxLength]="20"
  [value]="value('firstName')"
  (valueChange)="update('firstName', $event)"
  [error]="errors()['firstName']"
/>
<app-input-field
  label="PERSONS.LASTNAME_LABEL"
  [maxLength]="20"
  [value]="value('lastName')"
  (valueChange)="update('lastName', $event)"
  [error]="errors()['lastName']"
/>
  • Zeilen 7–21: die Anrede in einer Dropdown-Liste ([ion-select], siehe Beispiel 05), mit Label und Fehlermeldung wie ein Eingabefeld; [interface="popover"]: Die Liste öffnet sich unterhalb des Felds (standardmäßig in einem Dialogfeld).
  • Zeilen 23–36: Vorname und Nachname: zwei Eingabefelder. Fehlermeldungen erscheinen unter dem vom Server erwarteten Feldnamen ([errors()['firstName']]).

11.12.10. src/app/components/captcha-field.ts

// =========================================================================
// src/app/components/captcha-field.ts - das CAPTCHA-Bild und das Eingabefeld
// -------------------------------------------------------------------------
// Eine Anzeigekomponente: das Bild (svg), die Schaltfläche "Anderes Bild"
// (Output reload) und das Feld, vom Eltern-Formular GESTEUERT
// (value, valueChange). Das Bild und seine Kennung werden vom
// Server durch die Anmeldeseite angefordert, die sie zum Senden der Antwort braucht.
// =========================================================================

import { Component, computed, inject, input, output } from '@angular/core';
import { IonButton, IonIcon } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { refresh } from 'ionicons/icons';
import { Translations } from '../i18n/translations';
import { InputField } from './input-field';

@Component({
  selector: 'app-captcha-field',
  imports: [IonButton, IonIcon, InputField],
  templateUrl: './captcha-field.html',
  styles: `
    .label {
      font-size: 13px;
      color: var(--ion-color-step-700, #444);
    }
    .row {
      display: flex;
      align-items: center;
      gap: 8px;
    }
    .image {
      width: 160px;
      height: 54px;
      background: #f5f7fa;
      border: 1px solid #d0d0d0;
      border-radius: 6px;
      object-fit: contain;
    }
  `,
})
export class CaptchaField {
  readonly t = inject(Translations).t;

  readonly svg = input<string>();
  readonly value = input.required<string>();
  readonly error = input<string>();
  readonly valueChange = output<string>();
  readonly reload = output<void>();

  // das SVG-Bild (Text) -> eine "data:"-Adresse, die ein <img>-Tag
  // anzeigen kann. Ein Bild kann kein Skript ausführen: Es ist unbedenklich
  readonly source = computed(() => {
    const svg = this.svg();
    return svg ? `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}` : undefined;
  });

  constructor() {
    addIcons({ refresh });
  }
}

Das CAPTCHA-Bild, die Schaltfläche „Anderes Bild“ und das Eingabefeld. Die Komponente ruft den Server nicht auf: Der Anmeldescreen fordert das Bild an, da er dessen Kennung benötigt, um die Antwort zu senden.

  • Zeilen 21–39: die Stile der Komponente, direkt in der Komponente selbst geschrieben ([styles]): Sie sind kurz;
  • Zeile 48: ein leerer Output ([output<void>()]): „Der Benutzer möchte ein anderes Bild“;
  • Zeilen 52–55: Das SVG-Bild wird als Text empfangen (Beispiel 22). Es wird in eine „data:“-URL umgewandelt (den in der URL selbst kodierten Inhalt der Datei), die ein [img]-Tag anzeigen kann. Das ist sicher: Ein Bild kann keine Skripte ausführen, während ein per [innerHTML] in die Seite eingefügtes SVG dies könnte ([Angular] würde es ablehnen, sofern es nicht ausdrücklich erlaubt wird).

11.12.11. src/app/components/captcha-field.html

<!-- ======================================================================
     captcha-field.html - das CAPTCHA-Bild und das Eingabefeld
     ====================================================================== -->

<div class="label">{{ t('CAPTCHA.LABEL') }}</div>
<div class="row">
  @if (source(); as source) {
    <!-- alt: was ein Screenreader anstelle des Bildes vorliest -->
    <img class="image" [src]="source" [alt]="t('CAPTCHA.IMAGE_ALT')" />
  } @else {
    <div class="image"></div>
  }
  <ion-button fill="clear" (click)="reload.emit()">
    <ion-icon slot="start" name="refresh" />
    {{ t('CAPTCHA.NEW_IMAGE') }}
  </ion-button>
</div>
<app-input-field
  label="CAPTCHA.LABEL"
  help="CAPTCHA.HELP"
  [maxLength]="10"
  [value]="value()"
  (valueChange)="valueChange.emit($event)"
  [error]="error()"
/>
  • Zeile 9: [alt]: was ein Screenreader ([TalkBack] von [Android]) anstelle des Bildes vorliest;
  • Zeilen 13–16: „Anderes Bild“ gibt [reload] aus;
  • Zeilen 18–25: das Feld, das ebenfalls vom übergeordneten Element gesteuert wird: Die Komponente reicht den Wert und etwaige Änderungen daran weiter.

11.12.12. src/app/components/confirmation.ts

// =========================================================================
// src/app/components/confirmation.ts - "Sind Sie sicher?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 16. Ein Service, der ein Ionic-Dialogfenster öffnet
// (AlertController). Die Meldung ist ein Übersetzungs-SCHLÜSSEL:
//     if (await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM')) { ... }
// "Nein, zurück" statt "Abbrechen": Die Frage lautet manchmal "Diesen
// Termin stornieren?", und eine Schaltfläche "Abbrechen" wäre dort zweideutig.
// Eine neue Frage löscht die Meldungen der vorherigen Aktion.
// =========================================================================

import { inject, Injectable } from '@angular/core';
import { AlertController } from '@ionic/angular';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';

@Injectable({ providedIn: 'root' })
export class Confirmation {
  private readonly alerts = inject(AlertController);
  private readonly messages = inject(Messages);
  private readonly t = inject(Translations).t;

  async ask(key: string): Promise<boolean> {
    this.messages.clear();
    const alert = await this.alerts.create({
      // eine CSS-Klasse für das Fenster: seine Breite (siehe styles.scss)
      cssClass: 'confirmation',
      header: this.t('CONFIRMATION.TITLE'),
      message: this.t(key),
      buttons: [
        // role 'cancel': die Schaltfläche Nein; ein Drücken außerhalb des Dialogs oder die
        // Zurück-Taste des Telefons ergeben die Rolle 'backdrop': Nur 'confirm' bedeutet Ja
        { text: this.t('CONFIRMATION.NO'), role: 'cancel' },
        // cssClass: die rote Schaltfläche (siehe styles.scss)
        { text: this.t('CONFIRMATION.YES'), role: 'confirm', cssClass: 'danger-button' },
      ],
    });
    await alert.present();
    // onDidDismiss: ein Promise, beim Schließen mit der Rolle der Schaltfläche aufgelöst
    const { role } = await alert.onDidDismiss();
    return role === 'confirm';
  }
}

Das Bestätigungsfenster aus Beispiel 16, verwendet als: [if (await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM')) ...]. Ein Service, da er selbst nichts anzuzeigen hat: Es ist der [AlertController] von [Ionic] , der das Dialogfeld erzeugt.

  • Zeile 24: Eine neue Frage löscht die Meldungen der vorherigen Aktion;
  • Zeile 27: eine CSS-Klasse für das Dialogfeld: seine Breite (siehe [styles.scss]);
  • Zeilen 33–35: die Schaltflächen. Ein Tippen außerhalb des Dialogfelds oder das Drücken der Zurück-Taste des Telefons schließt das Dialogfeld mit der Rolle [backdrop] (siehe Beispiel 16): Nur „Ja, bestätigen“ ([confirm]) bestätigt;
  • Zeilen 38–41: [present()] zeigt das Dialogfeld an; [onDidDismiss()] gibt ein [Promise] zurück, das beim Schließen aufgelöst wird, mit der Rolle der Schaltfläche, auf die getippt wurde.

11.12.13. src/app/components/booking-dialog.ts

// =========================================================================
// src/app/components/booking-dialog.ts - der Inhalt des Dialogs zum
// Buchen eines Zeitfensters
// -------------------------------------------------------------------------
// Der Dialog selbst ist ein <ion-modal> des Terminkalender-Bildschirms, geöffnet,
// wenn seine ADRESSE es verlangt (/schedule?...&book=7, siehe
// pages/schedule.ts): Die Adresse beschreibt so den ganzen Bildschirm einschließlich des Dialogs.
// Diese Komponente ist nur sein INHALT.
//
// Sie spricht nicht mit dem Server: Sie sendet
//   - confirm, mit dem gewählten Patienten (undefined für einen Patienten, der
//     für sich selbst bucht);
//   - close.
// Der Terminkalender-Bildschirm entscheidet, was damit geschieht.
// =========================================================================

import { Component, inject, input, output, signal } from '@angular/core';
import { IonButton, IonSelect, IonSelectOption, SelectCustomEvent } from '@ionic/angular';
import { label, Person } from '../api/types';
import { Translations } from '../i18n/translations';

@Component({
  selector: 'app-booking-dialog',
  imports: [IonButton, IonSelect, IonSelectOption],
  templateUrl: './booking-dialog.html',
  styles: `
    :host {
      display: block;
      padding: 20px;
    }
    h2 {
      margin-top: 0;
      font-size: 22px;
      font-weight: 400;
    }
    .buttons {
      display: flex;
      justify-content: flex-end;
      flex-wrap: wrap;
      gap: 8px;
      margin-top: 20px;
    }
  `,
})
export class BookingDialog {
  readonly t = inject(Translations).t;
  readonly label = label;

  readonly timeRange = input.required<string>(); // "8:00 - 8:20"
  // ADMIN / DOCTOR: die zur Auswahl stehenden Patienten
  readonly clients = input<Person[]>([]);
  // USER: Der Patient ist der Benutzer selbst
  readonly patient = input<string>();
  readonly submitting = input(false);
  readonly confirm = output<number | undefined>();
  readonly close = output<void>();

  // der in der Liste gewählte Patient
  readonly clientId = signal<number | undefined>(undefined);

  choose(event: SelectCustomEvent<number>): void {
    this.clientId.set(event.detail.value);
  }
}

Der Inhalt des Fensters zur Terminbuchung. Das Fenster selbst ist ein [ion-modal] des Kalenderscreens, das geöffnet wird, wenn seine Adresse dies verlangt ([&book=7], siehe [schedule.html]).

  • Zeilen 49–56: Die Komponente kommuniziert nicht mit dem Server: Sie erhält, was sie anzeigt, und sendet zwei Antworten – eine zum Bestätigen (mit dem ausgewählten Patienten) und eine zum Schließen des Fensters. Wenn ein Patient für sich selbst einen Termin bucht, erhält sie seinen eigenen Namen ([patient]) und keine Liste;
  • Zeile 59: Der aus der Liste ausgewählte Patient: der Zustand des Fensters.

11.12.14. src/app/components/booking-dialog.html

<!-- ======================================================================
     booking-dialog.html - der Inhalt des Buchungsdialogs
     ====================================================================== -->

<h2>{{ t('BOOKING_DIALOG.TITLE') }}</h2>
<p>{{ t('BOOKING_DIALOG.SLOT', { time: timeRange() }) }}</p>

<!-- ein Patient bucht für sich selbst: keine Liste (und der Server
     würde ohnehin jede clientId ignorieren) -->
@if (patient(); as patient) {
  <p>{{ t('BOOKING_DIALOG.PATIENT_LABEL') }}: <strong>{{ patient }}</strong></p>
} @else {
  <!-- placeholder: der angezeigte Text, solange kein Patient gewählt ist -->
  <ion-select
    [label]="t('BOOKING_DIALOG.PATIENT_LABEL')"
    fill="outline"
    labelPlacement="stacked"
    interface="popover"
    [placeholder]="t('BOOKING_DIALOG.CHOOSE_PATIENT')"
    [value]="clientId()"
    (ionChange)="choose($event)"
  >
    @for (c of clients(); track c.id) {
      <ion-select-option [value]="c.id">{{ label(c) }}</ion-select-option>
    }
  </ion-select>
}

<div class="buttons">
  <ion-button fill="clear" (click)="close.emit()">{{ t('BOOKING_DIALOG.CANCEL') }}</ion-button>
  <ion-button [disabled]="submitting()" (click)="confirm.emit(clientId())">
    {{ t('BOOKING_DIALOG.CONFIRM') }}
  </ion-button>
</div>
  • Zeilen 10–11: Ein Patient bucht für sich selbst: sein Name, ohne Liste;
  • Zeilen 14–26: Der ADMIN oder der Arzt wählt den Patienten aus einer Dropdown-Liste aus; [placeholder]: der Text, der angezeigt wird, solange kein Patient ausgewählt ist;
  • Zeilen 29–34: die rechtsbündigen Schaltflächen; „Bestätigen“ ist während des Absendens deaktiviert.

11.13. Die Screens

Jeder Screen ist eine Komponente, die der Router bei Bedarf lädt (siehe [app.routes.ts]) und deren Template mit [ion-content] beginnt: dem scrollbaren Bereich zwischen der oberen Leiste und dem Fehlerbereich des Layouts.

11.13.1. src/app/pages/login.ts

// =========================================================================
// src/app/pages/login.ts - der Anmeldebildschirm (/login)
// -------------------------------------------------------------------------
// Derselbe Bildschirm wie bei den anderen Clients: Login, Passwort, CAPTCHA und
// eine zweite Schaltfläche "Patientenkonto anlegen", die dasselbe CAPTCHA prüft,
// bevor die Kontoerstellung geöffnet wird.
//
// /login?login=jbernard: Das Feld login ist vorausgefüllt (direkt nach dem
// Anlegen eines Kontos).
// Nach einer erfolgreichen Anmeldung navigiert dieser Bildschirm NICHT selbst: Die
// Sitzung ändert sich, die Router-Guards werden neu ausgewertet (siehe app.ts), und
// der Guard verlässt den Anmeldebildschirm (zu ?redirect=... oder zur
// Startseite der Rolle, siehe app.routes.ts).
// =========================================================================

import { Component, inject, input, linkedSignal, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, ViewWillEnter } from '@ionic/angular';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { Captcha } from '../api/types';
import { CaptchaField } from '../components/captcha-field';
import { InputField } from '../components/input-field';
import { FormSubmission } from '../components/form-submission';
import { Messages } from '../state/messages';
import { Session } from '../state/session';
import { Translations } from '../i18n/translations';

// die Demo-Konten
const demoAccounts = [
  { accounts: 'admin', key: 'LOGIN.DEMO_ADMIN' },
  { accounts: 'pelissier, tatou, dupont', key: 'LOGIN.DEMO_DOCTOR' },
  { accounts: 'martin, durand, bistrou, german', key: 'LOGIN.DEMO_USER' },
];

@Component({
  selector: 'app-login',
  imports: [IonContent, IonButton, InputField, CaptchaField],
  templateUrl: './login.html',
})
export class LoginPage implements ViewWillEnter {
  private readonly api = inject(RdvMedecinsApi);
  private readonly session = inject(Session);
  private readonly router = inject(Router);
  private readonly messages = inject(Messages);
  readonly t = inject(Translations).t;
  readonly submission = new FormSubmission(this.messages);
  readonly demoAccounts = demoAccounts;

  // der Login der Adresse (?login=...), vom Router übergeben
  // (withComponentInputBinding, siehe main.ts)
  readonly login = input<string>();
  // das Formular: ein Signal, das mit dem Input login VERKNÜPFT ist. Es beginnt damit (höchstens 30
  // Zeichen), kann danach geändert werden und beginnt wieder damit,
  // wenn sich die Adresse ändert
  readonly form = linkedSignal(() => ({ login: (this.login() ?? '').slice(0, 30), password: '', captcha: '' }));
  readonly captcha = signal<Captcha | null>(null);

  // ionViewWillEnter: von Ionic jedes Mal aufgerufen, wenn der Bildschirm gleich
  // angezeigt wird (beim ersten Mal und bei der Rückkehr zu ihm)
  ionViewWillEnter(): void {
    void this.reloadCaptcha();
  }

  // ein neues Bild: Es wird nach JEDEM Versuch gebraucht, denn ein Bild wird
  // nur EINMAL verwendet (der Server vergisst es, sobald er es geprüft hat)
  async reloadCaptcha(): Promise<void> {
    try {
      this.captcha.set(await this.api.captcha());
    } catch {
      this.captcha.set(null); // Server nicht erreichbar: Die Anmeldung scheitert mit einer klaren Meldung
    }
  }

  update(field: 'login' | 'password' | 'captcha', value: string): void {
    // ein NEUES Objekt: Das Signal ändert seinen Wert
    this.form.update((f) => ({ ...f, [field]: value }));
    this.submission.clearError(field);
  }

  // die beiden Schaltflächen teilen sich diese Abfolge: Senden, dann bei einem Fehlschlag
  // Fehlermeldung und NEUES Bild
  private async attempt(action: () => Promise<void>): Promise<void> {
    this.messages.clear();
    const succeeded = await this.submission.submit(action);
    if (!succeeded) {
      this.form.update((f) => ({ ...f, captcha: '' }));
      await this.reloadCaptcha();
    }
  }

  // bei Erfolg ist hier nichts weiter zu tun: Der Guard wechselt den Bildschirm
  logIn(): Promise<void> {
    const f = this.form();
    return this.attempt(() => this.session.logIn(f.login.trim(), f.password, this.captcha()?.id ?? '', f.captcha));
  }

  createAccount(): Promise<void> {
    return this.attempt(async () => {
      await this.api.registrationAccess(this.captcha()?.id ?? '', this.form().captcha);
      await this.router.navigateByUrl('/register');
    });
  }
}

Der Anmeldescreen.

  • Zeilen 29–33: die Demo-Konten, die unterhalb des Formulars angezeigt werden;
  • Zeilen 41–47: die Services (per [inject()] bezogen), das Absenden des Formulars und die Demo-Konten;
  • Zeile 51: die Adresse für die Anmeldung ([/login?login=jbernard], nach der Erstellung eines Kontos), vom Router diesem Input zugewiesen;
  • Zeile 55: die Eingabe: ein Objekt (Feldname → Wert) in einem [linkedSignal]: ein veränderbarer Wert, der aber an eine Berechnung GEKOPPELT ist. Er BEGINNT mit dem berechneten Wert (der Anmeldeadresse, bis zu 30 Zeichen); er kann später geändert werden, und die Berechnung startet neu, wenn sich der Input [login] ändert. Bei der Initialisierung eines Felds kann ein Input nicht gelesen werden (er hat seinen Wert noch nicht erhalten): Das [linkedSignal] löst dieses Problem;
  • Zeile 56: das empfangene CAPTCHA (seine ID und sein Bild);
  • Zeilen 60–62: [ionViewWillEnter]: eine Methode, die [Ionic] jedes Mal aufruft, wenn der Screen gleich angezeigt wird; beim ersten Mal UND bei der Rückkehr zum Screen (der im Speicher gehaltene Screen wird nicht neu erzeugt). Hier wird ein neues Bild angefordert: Das Bild des vorherigen Besuchs könnte bereits verwendet worden sein;
  • Zeilen 66–72: ein neues Bild beim Öffnen des Screens, auf Anforderung und nach JEDEM Versuch (ein Bild wird nur einmal verwendet);
  • Zeilen 74–78: ein geändertes Feld: ein NEUES Objekt ([{ ...f, [field]: value }]: eine Kopie, in der sich ein Feld ändert), und der Feldfehler verschwindet. Der Parameter [field] akzeptiert nur die drei Namen aus der Eingabe: Ein Tippfehler würde einen Kompilierfehler verursachen;
  • Zeilen 82–89: Beide Schaltflächen folgen dieser Abfolge: Absenden, dann, bei Misserfolg, wird das CAPTCHA geleert und ein neues Bild angezeigt;
  • Zeilen 92–95: die Anmeldung. Bei Erfolg unternimmt der Screen nichts weiter: Die Sitzung ändert sich, die Guards werden neu ausgewertet, und der Guard verlässt den Anmeldescreen (siehe [app.routes.ts]);
  • Zeilen 97–102: „Patientenkonto erstellen“: Der Server prüft das CAPTCHA und stellt ein Token aus (ein Cookie); anschließend öffnet sich der Screen zur Kontoerstellung.

11.13.2. src/app/pages/login.html

<!-- ======================================================================
     login.html - der Login-Bildschirm
     ====================================================================== -->

<ion-content class="ion-padding">
  <h1>{{ t('LOGIN.TITLE') }}</h1>

  <!-- autocomplete: Der Passwortmanager des Telefons kann
       das Formular ausfüllen -->
  <app-input-field
    label="LOGIN.LOGIN_LABEL"
    autocomplete="username"
    [value]="form().login"
    (valueChange)="update('login', $event)"
    [error]="submission.errors()['login']"
  />
  <app-input-field
    label="LOGIN.PASSWORD_LABEL"
    autocomplete="current-password"
    [secret]="true"
    [value]="form().password"
    (valueChange)="update('password', $event)"
    [error]="submission.errors()['password']"
  />
  <app-captcha-field
    [svg]="captcha()?.svg"
    [value]="form().captcha"
    (valueChange)="update('captcha', $event)"
    (reload)="reloadCaptcha()"
    [error]="submission.errors()['captcha']"
  />

  <!-- expand="block": die volle Breite -->
  <ion-button expand="block" shape="round" [disabled]="submission.inProgress()" (click)="logIn()">
    {{ t('LOGIN.SUBMIT') }}
  </ion-button>
  <ion-button expand="block" shape="round" fill="outline" [disabled]="submission.inProgress()" (click)="createAccount()">
    {{ t('LOGIN.CREATE_ACCOUNT') }}
  </ion-button>
  <p class="ion-text-center help">{{ t('LOGIN.CREATE_ACCOUNT_HELP') }}</p>

  <!-- die Demo-Konten -->
  <div class="demo">
    <div>{{ t('LOGIN.DEMO_ACCOUNTS') }}</div>
    @for (d of demoAccounts; track d.key) {
      <div>• <code>{{ d.accounts }}</code> - {{ t(d.key) }}</div>
    }
  </div>
</ion-content>
  • Zeilen 10–24: der Benutzername und das Passwort. [autocomplete]: Der Passwortmanager des Telefons füllt sie aus und bietet nach der Anmeldung an, das Konto zu speichern;
  • Zeilen 25–31: das CAPTCHA; sein Bild wird vom Server gesendet, nachdem der Screen angezeigt wurde: [captcha()?.svg] entspricht bis dahin [undefined] ;
  • Zeilen 34–39: die beiden Schaltflächen, über die gesamte Breite ([expand="block"]), werden während des Absendens deaktiviert;
  • Zeilen 43–48: die Demo-Konten: eine Schleife [@for] (siehe Beispiel 03) über das Array [login.ts]; [track d.key]: das jedes Element identifiziert.

11.13.3. src/app/pages/schedule.ts

// =========================================================================
// src/app/pages/schedule.ts - der Terminkalender-Bildschirm (/schedule)
// -------------------------------------------------------------------------
// Drei Blöcke wie bei den anderen Clients:
//   1. die Wahl des Arztes und des Tages;
//   2. der Terminkalender dieses Arztes an diesem Tag;
//   3. der Dialog zum Buchen eines Zeitfensters (ein <ion-modal>).
//
// Der GESAMTE Zustand des Bildschirms steckt in seiner ADRESSE:
//     /schedule?doctorId=1&day=2026-10-05              der Terminkalender
//     /schedule?doctorId=1&day=2026-10-05&book=7       + der Buchungsdialog
// Der Router übergibt diese drei Parameter an die Inputs der Komponente
// (withComponentInputBinding); der Bildschirm LEITET daraus ab, was er anzeigt
// (computed-Signals), und die Aktionen des Benutzers ändern die Adresse.
// Im Web kann man die Seite daher neu laden, als Lesezeichen speichern,
// Zurück / Vorwärts verwenden; auf dem Telefon schließt die Zurück-Taste
// den Buchungsdialog.
//
// Was jeder sieht und tun kann, entscheidet der SERVER (Felder
// patient, mine, bookable, appointmentId jedes Zeitfensters): Der Bildschirm
// zeigt es lediglich an. Ein Patient erhält nicht einmal die Namen der anderen Patienten.
// =========================================================================

import { Location } from '@angular/common';
import { Component, computed, effect, inject, input, linkedSignal, resource, signal } from '@angular/core';
import { Router } from '@angular/router';
import {
  DatetimeCustomEvent, IonButton, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonCardTitle, IonContent,
  IonDatetime, IonIcon, IonItem, IonLabel, IonList, IonModal, IonSelect, IonSelectOption, IonSpinner,
  SelectCustomEvent,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { calendarOutline } from 'ionicons/icons';
import { ApiError } from '../api/api-error';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { ScheduleSlot, label } from '../api/types';
import { positiveInteger } from '../app.routes';
import { Confirmation } from '../components/confirmation';
import { BookingDialog } from '../components/booking-dialog';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { isManager, isPatient, Session } from '../state/session';
import { today, isValidDate, timeRange, longDay } from '../formatting';
import { Translations } from '../i18n/translations';

// die Adresse des Terminkalenders (ohne den Buchungsdialog oder mit ihm)
export function scheduleUrl(doctorId: number | undefined, day: string, book?: number): string {
  const params = new URLSearchParams({ doctorId: String(doctorId ?? ''), day });
  if (book !== undefined) params.set('book', String(book));
  return `/schedule?${params}`;
}

@Component({
  selector: 'app-schedule',
  imports: [
    IonContent, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonCardSubtitle, IonSelect, IonSelectOption,
    IonItem, IonLabel, IonIcon, IonButton, IonList, IonSpinner, IonModal, IonDatetime, BookingDialog,
  ],
  templateUrl: './schedule.html',
  styleUrl: './schedule.scss',
})
export class SchedulePage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  private readonly location = inject(Location);
  private readonly confirmation = inject(Confirmation);
  private readonly translations = inject(Translations);
  readonly t = this.translations.t;
  readonly user = inject(Session).user;
  readonly timeRange = timeRange;
  readonly label = label;

  // die Parameter der Adresse, wie sie sind (Texte, möglicherweise ungültig)
  readonly doctorId = input<string>();
  readonly day = input<string>();
  readonly book = input<string>();

  // was daraus abgeleitet wird: COMPUTED-Signals (computed), neu berechnet, wenn
  // sich die Adresse ändert
  readonly urlDoctorId = computed(() => positiveInteger(this.doctorId()));
  private readonly bookId = computed(() => positiveInteger(this.book()));
  // der Tag: der der Adresse, wenn er gültig ist, sonst heute
  readonly invalidDay = computed(() => {
    const day = this.day();
    return day !== undefined && !isValidDate(day);
  });
  readonly shownDay = computed(() => (this.invalidDay() ? today() : (this.day() ?? today())));

  // ==================================================== die Daten
  // resource: ein asynchrones Lesen, durch Signals beschrieben. loader wird
  // jedes Mal erneut aufgerufen, wenn sich params ändert; ein undefined params: nichts zu lesen
  readonly doctors = resource({
    loader: () => this.cache.read('doctors', () => this.api.list('doctors')),
  });
  // die Patienten: nur für diejenigen, die das Recht haben, sie zu lesen (Buchungsdialog)
  readonly clients = resource({
    params: () => (isManager(this.user()) ? true : undefined),
    loader: () => this.cache.read('clients', () => this.api.list('clients')),
  });
  // ohne Arzt in der Adresse sieht ein DOCTOR SEINEN Terminkalender (der Server
  // findet ihn anhand des Tokens); die anderen sehen nichts
  readonly schedule = resource({
    params: () => {
      const id = this.urlDoctorId();
      if (this.invalidDay() || (id === undefined && this.user()?.role !== 'DOCTOR')) return undefined;
      return { id, day: this.shownDay() };
    },
    loader: ({ params: { id, day } }) => this.cache.read(`schedule/${id}/${day}`, () => this.api.schedule(id, day)),
  });

  // der erhaltene Terminkalender (undefined: noch nicht eingetroffen, gescheitert oder kein Terminkalender)
  readonly s = computed(() => (this.schedule.hasValue() ? this.schedule.value() : undefined));
  // der angezeigte Arzt: der der Adresse oder der des erhaltenen Terminkalenders (DOCTOR)
  readonly shownDoctorId = computed(() => this.urlDoctorId() ?? this.s()?.doctor.id);
  // das Zeitfenster, dessen Buchungsdialog offen ist (&book=7),
  // nur wenn es von diesem Benutzer gebucht werden kann
  readonly toBook = computed(() => this.s()?.slots.find((c) => c.id === this.bookId() && c.bookable));
  // Patient, der bereits einen bevorstehenden Termin hat: warum es keine
  // Schaltfläche "Buchen" gibt; nutzlos im Terminkalender, der diesen Termin enthält
  readonly info = computed(() => {
    const s = this.s();
    return s?.info && !s.slots.some((c) => c.mine) ? s.info : undefined;
  });
  // USER: der Name des Patienten, im Buchungsdialog angezeigt
  readonly patient = computed(() => {
    const u = this.user();
    return isPatient(u) ? u?.name : undefined;
  });

  // ==================================================== 1. die Wahl des Arztes und des Tages
  // ein kleines Formular, dessen Zustand nur vor dem Absenden verwendet wird. linkedSignal:
  // Es BEGINNT mit den Werten der Adresse und kehrt dazu zurück, wenn sie sich ändert
  readonly doctorChoice = linkedSignal(() => this.shownDoctorId());
  readonly dayChoice = linkedSignal(() => this.shownDay());
  readonly calendarOpen = signal(false);
  // die Sprache des Kalenders (ion-datetime): 'fr-FR' oder 'en-US'
  readonly locale = computed(() => (this.translations.language() === 'fr' ? 'fr-FR' : 'en-US'));
  // der gewählte Arzt muss in der Liste stehen (sonst: keiner)
  readonly knownId = computed(() => {
    const id = this.doctorChoice();
    const list = this.doctors.hasValue() ? this.doctors.value() : [];
    return list.some((d) => d.id === id) ? id : undefined;
  });

  readonly submitting = signal(false);
  // true, wenn der Dialog über die Schaltfläche "Buchen" dieses Bildschirms geöffnet wurde
  private openedHere = false;

  constructor() {
    addIcons({ calendarOutline });
    // ungültig gemachte Daten (Buchung, Stornierung): Sie werden erneut gelesen
    reloadAfterInvalidation(this.doctors, this.clients, this.schedule);
    // ein gescheitertes Lesen: seine Meldung, unten am Bildschirm
    reportErrors(this.doctors, this.clients, this.schedule);
    // ein ungültiger Tag in der Adresse: eine Meldung, die NACH dem Ende der
    // aktuellen Navigation angezeigt wird (setTimeout), die die Meldungen des
    // vorherigen Bildschirms löscht (siehe app.ts)
    effect(() => {
      if (this.invalidDay()) setTimeout(() => this.messages.showError('ERRORS.INVALID_DATE'));
    });
  }

  longDay(day: string): string {
    return longDay(day, this.translations.language());
  }

  chooseDoctor(event: SelectCustomEvent<number>): void {
    this.doctorChoice.set(event.detail.value);
  }

  // der Kalender: "2026-10-05" (oder "2026-10-05T00:00:00") -> "2026-10-05"
  chooseDay(event: DatetimeCustomEvent): void {
    const value = event.detail.value;
    if (typeof value === 'string') this.dayChoice.set(value.slice(0, 10));
    this.calendarOpen.set(false);
  }

  // "Terminkalender anzeigen" ändert die Adresse; der Router VERWENDET diese Komponente
  // WIEDER (gleiche Route): Nur ihre Inputs ändern sich, und alles wird neu berechnet
  view(): void {
    void this.router.navigateByUrl(scheduleUrl(this.knownId(), this.dayChoice()));
  }

  // "Buchen" ändert die ADRESSE (&book=...): Der Dialog öffnet sich
  openBooking(c: ScheduleSlot): void {
    this.openedHere = true;
    void this.router.navigateByUrl(scheduleUrl(this.shownDoctorId(), this.shownDay(), c.id));
  }

  // Schließen des Dialogs: zurück zur vorherigen Adresse
  closeBooking(): void {
    // die Adresse hat bereits kein &book= mehr (Zurück-Taste des Browsers): nichts zu tun
    if (this.bookId() === undefined) return;
    if (this.openedHere) {
      // wie die Zurück-Taste: Die Adresse mit &book= wird aus dem Verlauf entfernt
      this.openedHere = false;
      this.location.back();
    } else {
      // Bildschirm direkt über diese Adresse geöffnet: Sie wird ersetzt
      void this.router.navigateByUrl(scheduleUrl(this.shownDoctorId(), this.shownDay()), { replaceUrl: true });
    }
  }

  // der Server ist die Referenz: Nach jeder Aktion wird der Terminkalender erneut gelesen
  // (und der Bereich des Patienten, der seinen Termin zeigt). Die Invalidierung
  // benachrichtigt alle lebenden Terminkalender-Bildschirme, auch diesen
  private reload(): void {
    this.cache.invalidate('my-area');
    this.cache.invalidate('schedule');
  }

  async confirmBooking(slot: ScheduleSlot, clientId: number | undefined): Promise<void> {
    const manager = isManager(this.user());
    this.submitting.set(true);
    try {
      await this.api.book(this.shownDay(), slot.id, manager ? clientId : undefined);
      this.messages.flash({ key: 'SCHEDULE.BOOKED' });
    } catch (e) {
      if (!(e instanceof ApiError)) throw e;
      if (e.key === 'ERRORS.CHOOSE_PATIENT') {
        // kein Patient gewählt: Der Dialog bleibt offen
        this.messages.showError(e.key);
        return; // (finally läuft trotzdem)
      }
      // in der Zwischenzeit belegtes Zeitfenster, Patient, der bereits einen Termin hat ...: Die
      // Meldung wird im Terminkalender angezeigt, Dialog geschlossen
      this.messages.flash({ success: false, key: e.key, params: e.params });
    } finally {
      this.submitting.set(false);
    }
    this.closeBooking();
    this.reload();
  }

  async cancel(c: ScheduleSlot): Promise<void> {
    if (c.appointmentId === null || !(await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM'))) return;
    try {
      await this.api.cancelAppointment(c.appointmentId);
      this.messages.showSuccess('SCHEDULE.CANCELLED');
    } catch (e) {
      this.messages.showApiError(e);
    }
    this.reload();
  }

  goToMyArea(): void {
    void this.router.navigateByUrl('/my-area');
  }
}

Der funktionsreichste Screen: die Auswahl eines Arztes und eines Tages, der Kalender und das Buchungsfenster.

  • Zeilen 47–51: die Adresse des Kalenders. Der GESAMTE Zustand des Screens steckt in seiner Adresse; Benutzeraktionen ändern sie, und der Screen bestimmt anhand dieser Adresse, was angezeigt wird;
  • Zeilen 76–78: die drei Parameter der Adresse, vom Router an die Inputs übergeben. Es sind Zeichenketten, unverändert: Sie können fehlen oder ungültig sein;
  • Zeilen 82–89: was daraus abgeleitet wird: BERECHNETE Signale, die bei einer Änderung der Adresse neu berechnet werden. Das Datum aus der Adresse, sofern gültig; andernfalls das heutige;
  • Zeilen 94–96: [resource()]: ein asynchrones Lesen, beschrieben durch Signale (es ist der [FutureBuilder] von [Flutter], nur besser). Ihre Funktion [loader] gibt ein [Promise] zurück; die Ressource stellt Signale bereit: [value()], [isLoading()], [error()], [status()] ... Die Ärzte werden aus dem Cache gelesen: einmal für die gesamte Sitzung;
  • Zeilen 98–101: [params]: eine Berechnung, von der die Ressource abhängt. Jedes Mal, wenn sich ihr Wert ändert, wird [loader] mit diesem neuen Wert aufgerufen; ist er gleich [undefined], gibt es nichts zu lesen. Hier: die Patienten, nur wenn der Benutzer berechtigt ist, sie einzusehen (für das Terminfenster);
  • Zeilen 104–111: der Kalender; seine Parameter sind der Arzt und der Tag des Termins. „Terminkalender anzeigen“ ändert die Adresse; der Router VERWENDET den Screen (dieselbe Route) mit neuen Eingaben WIEDER; [params] ändert sich, und der Kalender wird neu gelesen, ohne dass etwas anderes geschrieben werden muss (der Client [Flutter] benötigte [didUpdateWidget]). Ist in der Adresse kein Arzt angegeben, sieht ein angemeldeter Arzt SEINEN Kalender (der Server ermittelt ihn anhand des Tokens); andere sehen nichts;
  • Zeile 114: der empfangene Kalender. Zuerst [hasValue()] : Das Lesen von [value()] aus einer fehlgeschlagenen Ressource würde einen Fehler verursachen;
  • Zeile 119: Der Zeitslot für das Buchungsfenster ist der aus der Adresse ([&book=7]), jedoch nur, wenn er von DIESEM BENUTZER buchbar ist (ein inzwischen vergebener Zeitslot, eine manuell erstellte Adresse: kein Buchungsfenster);
  • Zeilen 122–125: Der Server sendet diese Meldung ([info]) zusammen mit ALLEN Kalendern an einen Patienten, der bereits einen anstehenden Termin hat; im Kalender, der diesen Termin enthält (ein Zeitslot [mine]), ist sie jedoch überflüssig – und unmittelbar nach einer Buchung sogar irreführend: Der Patient sieht seinen Termin unter seinem Namen aufgeführt, mit einer Schaltfläche „Stornieren“. Daher wird sie nur in den anderen Kalendern angezeigt. [some]: wahr, wenn mindestens ein Element des Arrays die Bedingung erfüllt;
  • Zeilen 135–136: die Auswahl des Arztes und des Tages: ein kleines Formular, dessen Zustand mit den Werten der Adresse BEGINNT und zu ihnen ZURÜCKKEHRT, wenn sich die Adresse ändert (Zurück-Schaltfläche des Browsers): zwei [linkedSignal]. Der Client [Flutter] erreichte dies, indem er das Widget neu erzeugte (sein Schlüssel änderte sich mit der Adresse);
  • Zeile 139: die Sprache des Kalenders, in dem Format, das [ion-datetime] erwartet;
  • Zeilen 141–145: Der ausgewählte Arzt muss in der Liste enthalten sein (andernfalls: keiner, und „Terminkalender anzeigen“ ist deaktiviert);
  • Zeilen 154–156: ungültig gewordene Daten (Buchung, Stornierung): Die drei Ressourcen werden neu gelesen; schlägt ein Lesevorgang fehl, erscheint unten auf dem Bildschirm eine Meldung (siehe [cache.ts] und [messages.ts]);
  • Zeilen 160–162: ein ungültiges Datum in der Adresse: eine Meldung. Sie wird NACH dem Ende der aktuellen Navigation angezeigt ([setTimeout]: wenn der gesamte aktuelle Codeblock und der darauffolgende Code vollständig ausgeführt wurden); andernfalls würde der Wechsel zur „neuen Seite“ (siehe [app.ts]) sie sofort löschen;
  • Zeilen 174–178: der im Kalender ausgewählte Tag; [ion-datetime] liefert ein Datum im ISO-Format („2026-10-05“, manchmal gefolgt von der Uhrzeit);
  • Zeilen 182–184: „Terminkalender anzeigen“ ändert die Adresse;
  • Zeilen 187–190: „Buchen“ ändert ebenfalls die Adresse ([&book=...]): Ein NEUER Eintrag wird dem Navigationsverlauf hinzugefügt; das Buchungsfenster öffnet sich, weil die Adresse es verlangt. [openedHere] hält fest, dass dieser Screen es geöffnet hat;
  • Zeilen 193–204: das Fenster schließen: zur vorherigen Adresse zurückkehren. Wurde es von diesem Screen geöffnet, gehen wir im Verlauf zurück ([location.back()]), genau wie mit der Zurück-Taste eines Telefons oder der Zurück-Schaltfläche eines Browsers. Wurde der Screen direkt unter dieser Adresse geöffnet (im Web), liegt nichts dahinter: Wir ersetzen die Adresse durch die Adresse des Kalenders ([replaceUrl]). Enthält die Adresse nicht mehr [&book=] (man ist gerade zurücknavigiert), ist nichts zu tun;
  • Zeilen 209–212: Nach einer Buchung oder Stornierung haben die Daten des Servers Vorrang: Der Kalender (und der Patientenbereich) werden für ungültig erklärt; der Cache benachrichtigt die Kalenderscreens, die neu laden;
  • Zeilen 214–235: die Buchung. Ist kein Patient ausgewählt, bleibt das Fenster geöffnet und zeigt die Meldung an. Jede andere Aktion schließt das Fenster, und die Meldung (Erfolg oder Fehler – etwa ein inzwischen vergebener Zeitslot ...) ist eine Flash-Meldung, die erscheint, wenn die Adresse zur Adresse des Kalenders zurückkehrt;
  • Zeilen 237–246: die Stornierung, nach Bestätigung.

11.13.4. src/app/pages/schedule.html

<!-- ======================================================================
     schedule.html - der Terminkalender-Bildschirm
     ====================================================================== -->

<ion-content class="ion-padding">
  <!-- 1. die Wahl des Arztes und des Tages -->
  <ion-card class="picker">
    <ion-card-content>
      <ion-select
        [label]="t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')"
        fill="outline"
        labelPlacement="stacked"
        interface="popover"
        [placeholder]="t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')"
        [value]="knownId()"
        (ionChange)="chooseDoctor($event)"
      >
        @if (doctors.hasValue()) {
          @for (d of doctors.value(); track d.id) {
            <ion-select-option [value]="d.id">{{ label(d) }}</ion-select-option>
          }
        }
      </ion-select>
      <!-- der Tag: eine Zeile, die man berührt, um den Kalender zu öffnen -->
      <ion-item class="day" [button]="true" [detail]="false" lines="full" (click)="calendarOpen.set(true)">
        <ion-label>
          <p>{{ t('DOCTOR_DAY_PICKER.DAY_LABEL') }}</p>
          <h3>{{ longDay(dayChoice()) }}</h3>
        </ion-label>
        <ion-icon slot="end" name="calendar-outline" [attr.aria-label]="t('DOCTOR_DAY_PICKER.CHOOSE_DAY')" />
      </ion-item>
      <ion-button expand="block" shape="round" [disabled]="knownId() === undefined" (click)="view()">
        {{ t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE') }}
      </ion-button>
    </ion-card-content>
  </ion-card>

  <!-- der Kalender in einem Dialog; locale: die Sprache der Namen der
       Tage und Monate; showDefaultButtons: die Buttons Cancel / OK -->
  <ion-modal class="dialog" [isOpen]="calendarOpen()" (didDismiss)="calendarOpen.set(false)">
    <ng-template>
      <ion-datetime
        presentation="date"
        [value]="dayChoice()"
        [locale]="locale()"
        [firstDayOfWeek]="1"
        min="2020-01-01"
        max="2035-12-31"
        [showDefaultButtons]="true"
        [cancelText]="t('BOOKING_DIALOG.CANCEL')"
        doneText="OK"
        (ionChange)="chooseDay($event)"
      />
    </ng-template>
  </ion-modal>

  <!-- Patient, der bereits einen bevorstehenden Termin hat: warum es keine Schaltfläche "Buchen" gibt -->
  @if (info(); as info) {
    <ion-card class="info">
      <ion-item lines="none" color="none">
        <ion-label class="ion-text-wrap">{{ t(info) }}</ion-label>
        <ion-button slot="end" fill="clear" (click)="goToMyArea()">{{ t('APP.MENU_MY_AREA') }}</ion-button>
      </ion-item>
    </ion-card>
  }

  <!-- 2. der Terminkalender -->
  @if (s(); as s) {
    <ion-card class="schedule">
      <ion-card-header>
        <ion-card-title>{{ t('SCHEDULE.TITLE_PREFIX') }} {{ longDay(s.day) }}</ion-card-title>
        <ion-card-subtitle>{{ label(s.doctor) }}</ion-card-subtitle>
      </ion-card-header>
      @if (s.slots.length === 0) {
        <ion-card-content>{{ t('SCHEDULE.NO_SLOTS') }}</ion-card-content>
      }
      <ion-list lines="full">
        @for (c of s.slots; track c.id) {
          <!-- die buchbaren Zeitfenster sind leicht eingefärbt -->
          <ion-item [class.bookable]="c.bookable">
            <div slot="start" class="time-range">{{ timeRange(c) }}</div>
            <ion-label>
              @if (c.free) {
                <span class="tag free">{{ t('SCHEDULE.FREE') }}</span>
              } @else if (c.patient) {
                <span class="tag" [class.mine]="c.mine">{{ label(c.patient) }}</span>
              } @else {
                <span class="tag">{{ t('SCHEDULE.BOOKED_BY_OTHER') }}</span>
              }
            </ion-label>
            <!-- die vom SERVER erlaubten Schaltflächen (bookable, appointmentId) -->
            @if (c.bookable) {
              <ion-button slot="end" fill="outline" shape="round" (click)="openBooking(c)">
                {{ t('SCHEDULE.BOOK') }}
              </ion-button>
            } @else if (c.appointmentId !== null) {
              <ion-button slot="end" fill="outline" shape="round" color="danger" (click)="cancel(c)">
                {{ t('SCHEDULE.CANCEL_APPOINTMENT') }}
              </ion-button>
            }
          </ion-item>
        }
      </ion-list>
    </ion-card>
  } @else if (schedule.isLoading()) {
    <div class="ion-text-center ion-padding"><ion-spinner /></div>
  } @else if (schedule.status() === 'idle') {
    <p class="empty">{{ t('SCHEDULE.EMPTY_STATE') }}</p>
  }

  <!-- 3. der Buchungsdialog, nur geöffnet, wenn die Adresse
       &book=... enthält; er schließt sich (Zurück-Button, Tippen daneben...):
       didDismiss -->
  <ion-modal class="dialog" [isOpen]="toBook() !== undefined" (didDismiss)="closeBooking()">
    <ng-template>
      @if (toBook(); as slot) {
        <app-booking-dialog
          [timeRange]="timeRange(slot)"
          [clients]="clients.hasValue() ? clients.value() : []"
          [patient]="patient()"
          [submitting]="submitting()"
          (confirm)="confirmBooking(slot, $event)"
          (close)="closeBooking()"
        />
      }
    </ng-template>
  </ion-modal>
</ion-content>
  • Zeilen 9–23: die Liste der Ärzte; [labelPlacement="stacked"]: Das Label bleibt über dem Feld, sodass der Text „-- choose a doctor --“ ([placeholder]) sichtbar ist, solange kein Arzt ausgewählt wurde. Die Optionen warten auf die Liste: [@if (doctors.hasValue())];
  • Zeilen 25–31: Der Tag wird als Feld angezeigt (mit seinem Label darüber, dem ausgeschriebenen Datum und einem Kalender-Icon), in einem [ion-item] , auf das man tippt, um den Kalender zu öffnen;
  • Zeilen 32–34: „Terminkalender anzeigen“, deaktiviert, bis ein bekannter Arzt ausgewählt ist;
  • Zeilen 40–55: der Kalender, [ion-datetime], in einem Fenster ([ion-modal]), das durch das Signal [calendarOpen] geöffnet wird. [presentation="date"]: nur das Datum, ohne Uhrzeit; [locale]: die Sprache der Tages- und Monatsnamen; [firstDayOfWeek]: Die Woche beginnt am Montag; [showDefaultButtons]: die Schaltflächen „Abbrechen“ / „OK“. „OK“ sendet [ionChange] mit dem ausgewählten Datum und schließt dann das Fenster; [didDismiss]: Das Fenster wurde geschlossen (OK, Abbrechen, Tippen außerhalb, Zurück-Taste);
  • Zeilen 58–65: ein Patient, der bereits einen anstehenden Termin hat: warum es keine Schaltfläche „Buchen“ gibt (siehe [info], oben);
  • Zeilen 68–104: der Kalender. Eine Zeile pro Zeitslot: die Uhrzeit, ein Label (verfügbar, der Name des Patienten oder „Belegt“ für einen anderen Patienten) und die vom SERVER aktivierte Schaltfläche ([bookable], [appointmentId]). [@else if]: die Fortsetzung der Fälle eines [@if];
  • Zeilen 105–109: Der Terminkalender wird geladen: ein rotierendes Rädchen ([ion-spinner]); kein Kalender anzuzeigen (die Ressource ist inaktiv, [idle]): eine Aufforderung, einen Arzt und ein Datum auszuwählen;
  • Zeilen 114–127: das Buchungsfenster, geöffnet ([isOpen]) nur, wenn die Adresse einem buchbaren Zeitslot entspricht. Es kann sich auch von selbst schließen: durch die Zurück-Taste des Telefons oder ein Tippen daneben; [didDismiss] ruft dann [closeBooking] auf, das die Adresse validiert. Sein Inhalt ist ein [ng-template]: Er wird erst beim Öffnen erzeugt und beim Schließen zerstört (der ausgewählte Patient wird vergessen).

Der Client [Flutter] zeichnete das Buchungsfenster selbst (einen [Stack], einen grauen Hintergrund, eine Karte); [ion-modal] liefert all das, samt Öffnungsanimation und Behandlung der Zurück-Taste.

11.13.5. src/app/pages/schedule.scss

// =========================================================================
// schedule.scss - die Stile des Terminkalender-Bildschirms
// =========================================================================

ion-card {
  margin: 0 0 12px;
}

// der Tag: eine Zeile, die wie die Eingabefelder aussieht
ion-item.day {
  --padding-start: 0;
  --inner-padding-end: 0;
  margin-bottom: 12px;

  p {
    font-size: 13px;
  }

  h3 {
    font-size: 16px;
  }
}

// die für den Patienten bestimmte Information
ion-card.info {
  --background: #e1f5fe;
}

ion-card.schedule ion-card-title {
  font-size: 19px;
}

// die buchbaren Zeitfenster: ein blassgrüner Hintergrund
ion-item.bookable {
  --background: #e8f5e9;
}

.time-range {
  width: 96px;
  font-size: 14px;
  font-weight: 500;
}

// ein farbiges Tag (das "Badge" der anderen Clients); standardmäßig grau
.tag {
  display: inline-block;
  padding: 3px 8px;
  border-radius: 6px;
  color: white;
  background: #757575;
  font-size: 13px;
  font-weight: bold;
  white-space: normal;

  &.free {
    background: #388e3c;
  }

  &.mine {
    background: var(--ion-color-primary);
  }
}

.empty {
  padding: 0 16px;
  color: var(--ion-color-medium-shade);
}

Stile des Screens: Tagesansicht, Patienteninformationen (hellblauer Hintergrund), buchbare Zeitslots (hellgrüner Hintergrund), Terminkalender und farbige Labels (Zeilen 45–62: standardmäßig grau, grün für einen verfügbaren Zeitslot, indigo für den Termin des angemeldeten Patienten).

11.13.6. src/app/pages/persons-config.ts

// =========================================================================
// src/app/pages/persons-config.ts - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Verwaltungsbildschirme der Ärzte und der Clients sind IDENTISCH: gleiche
// Liste, gleiches Formular. Sie werden EINMAL geschrieben (persons.ts,
// person-form.ts); nur die Adresse der API und die
// Schlüssel der Beschriftungen ändern sich, hier beschrieben. Der Router übergibt jedem Bildschirm den Typ.
// =========================================================================

import { PersonType } from '../api/rdvmedecins-api';
import { Person } from '../api/types';

export interface PersonKeys {
  title: string; // "Ärzte"
  add: string; // "Arzt hinzufügen"
  edit: string; // "Arzt bearbeiten"
  empty: string; // "Kein Arzt."
  confirmDelete: string;
  added: string; // "Arzt {{name}} wurde hinzugefügt (Login: {{login}})."
  edited: string;
  deleted: string;
  notFound: string; // der Datensatz wurde in der Zwischenzeit gelöscht
}

// Record<PersonType, ...>: ein Objekt, das GENAU eine Eigenschaft pro
// Typ hat (der Compiler prüft, dass keine vergessen wird)
const allKeys: Record<PersonType, PersonKeys> = {
  doctors: {
    title: 'DOCTORS.TITLE',
    add: 'DOCTORS.ADD',
    edit: 'DOCTORS.EDIT',
    empty: 'DOCTORS.EMPTY',
    confirmDelete: 'DOCTORS.DELETE_CONFIRM',
    added: 'DOCTORS.ADDED',
    edited: 'DOCTORS.UPDATED',
    deleted: 'DOCTORS.DELETED',
    notFound: 'ERRORS.DOCTOR_NOT_FOUND',
  },
  clients: {
    title: 'CLIENTS.TITLE',
    add: 'CLIENTS.ADD',
    edit: 'CLIENTS.EDIT',
    empty: 'CLIENTS.EMPTY',
    confirmDelete: 'CLIENTS.DELETE_CONFIRM',
    added: 'CLIENTS.ADDED',
    edited: 'CLIENTS.UPDATED',
    deleted: 'CLIENTS.DELETED',
    notFound: 'ERRORS.PATIENT_NOT_FOUND',
  },
};

export const keys = (type: PersonType): PersonKeys => allKeys[type];

// {{name}} und {{login}} der Meldungen "hinzugefügt / bearbeitet / gelöscht"
export const messageParams = (p: Person): Record<string, string> => ({
  name: `${p.firstName} ${p.lastName}`,
  login: p.login ?? '',
});

Die Screens für Ärzte und Clients sind identisch; nur die hier beschriebenen Label-Schlüssel unterscheiden sich.

  • Zeilen 13–23: Schlüssel für einen Personentyp, beschrieben durch ein Interface;
  • Zeilen 27–50: [Record<PersonType, PersonKeys>]: ein Objekt, das GENAU eine Eigenschaft pro Personentyp hat. Das Hinzufügen eines Werts zu [PersonType] würde hier einen Kompilierfehler verursachen, solange seine Schlüssel nicht definiert sind;
  • Zeilen 55–58: die Parameter für die Meldungen „hinzugefügt“, „geändert“ und „gelöscht“.

11.13.7. src/app/pages/persons.ts

// =========================================================================
// src/app/pages/persons.ts - die Liste der Ärzte ODER der Clients (ADMIN)
// -------------------------------------------------------------------------
// Ein einziger Bildschirm für beide: Der Typ (Ärzte oder Clients) kommt als
// Input an (die Eigenschaft data der Route, siehe app.routes.ts); die
// jeweils spezifischen Beschriftungen stehen in persons-config.ts.
// Auf einem Telefon passt eine Tabelle mit fünf Spalten nicht: eine
// Listenzeile pro Person (Name, Login) mit ihren zwei Schaltflächen; die runde
// Schaltfläche "+" (<ion-fab>) fügt eine Person hinzu.
// =========================================================================

import { Component, computed, inject, input, resource } from '@angular/core';
import { Router } from '@angular/router';
import {
  IonButton, IonCard, IonContent, IonFab, IonIcon, IonItem, IonLabel, IonSpinner,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { add, createOutline, trashOutline } from 'ionicons/icons';
import { RdvMedecinsApi, PersonType } from '../api/rdvmedecins-api';
import { label, Person } from '../api/types';
import { Confirmation } from '../components/confirmation';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { Translations } from '../i18n/translations';
import { keys, messageParams } from './persons-config';

@Component({
  selector: 'app-persons',
  imports: [IonContent, IonCard, IonItem, IonLabel, IonButton, IonIcon, IonFab, IonSpinner],
  templateUrl: './persons.html',
  styleUrl: './persons.scss',
})
export class PersonsPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  private readonly confirmation = inject(Confirmation);
  readonly t = inject(Translations).t;
  readonly label = label;

  readonly type = input.required<PersonType>();
  readonly c = computed(() => keys(this.type()));

  // die Liste aus dem Cache; params: der Typ (der Router könnte den Bildschirm
  // für den anderen Typ wiederverwenden, /doctors -> /clients)
  readonly list = resource({
    params: () => this.type(),
    loader: ({ params: type }) => this.cache.read(type, () => this.api.list(type)),
  });

  constructor() {
    addIcons({ add, createOutline, trashOutline });
    reloadAfterInvalidation(this.list);
    reportErrors(this.list);
  }

  // "Mme Marie PELISSIER" -> "MP"
  initials(p: Person): string {
    return `${p.firstName.charAt(0)}${p.lastName.charAt(0)}`;
  }

  add(): void {
    void this.router.navigateByUrl(`/${this.type()}/add`);
  }

  edit(p: Person): void {
    void this.router.navigateByUrl(`/${this.type()}/${p.id}/edit`);
  }

  async remove(p: Person): Promise<void> {
    const c = this.c();
    if (!(await this.confirmation.ask(c.confirmDelete))) return;
    try {
      await this.api.remove(this.type(), p.id);
      this.messages.showSuccess(c.deleted, messageParams(p));
    } catch (e) {
      // ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
      this.messages.showApiError(e);
    }
    // die Liste wird erneut gelesen (reloadAfterInvalidation)
    this.cache.invalidate(this.type());
  }
}

Die Liste der Ärzte oder Clients.

  • Zeile 42: der Typ (Ärzte oder Clients): die Eigenschaft [data] der Route, diesem Input zugewiesen;
  • Zeilen 47–50: die Liste, aus dem Cache. Würde der Router den Screen für den anderen Typ wiederverwenden, würde sich [params] ändern, und die andere Liste würde gelesen;
  • Zeilen 63–69: Hinzufügen und Bearbeiten öffnen das Formular über seine Adresse;
  • Zeilen 71–83: das Löschen, nach Bestätigung. Ein Arzt mit bestehenden Terminen wird vom Server abgelehnt (409 [DOCTOR_HAS_APPOINTMENTS]). In allen Fällen wird die Liste für ungültig erklärt und neu gelesen.

11.13.8. src/app/pages/persons.html

<!-- ======================================================================
     persons.html - die Liste der Ärzte oder der Clients
     ====================================================================== -->

<ion-content class="ion-padding">
  <h1>{{ t(c().title) }}</h1>

  @if (list.hasValue()) {
    @for (p of list.value(); track p.id) {
      <ion-card>
        <ion-item lines="none">
          <!-- die Initialen, in einem Kreis -->
          <div slot="start" class="initials">{{ initials(p) }}</div>
          <ion-label>
            <h2>{{ label(p) }}</h2>
            <p class="login">{{ p.login }}</p>
          </ion-label>
          <ion-button slot="end" fill="clear" color="medium" [title]="t('PERSONS.EDIT')" (click)="edit(p)">
            <ion-icon slot="icon-only" name="create-outline" />
          </ion-button>
          <ion-button slot="end" fill="clear" color="danger" [title]="t('PERSONS.DELETE')" (click)="remove(p)">
            <ion-icon slot="icon-only" name="trash-outline" />
          </ion-button>
        </ion-item>
      </ion-card>
    } @empty {
      <p>{{ t(c().empty) }}</p>
    }
  } @else if (list.isLoading()) {
    <!-- noch nicht geladen (oder das Laden ist gescheitert: Die Meldung steht unten am Bildschirm) -->
    <div class="ion-text-center ion-padding"><ion-spinner /></div>
  }

  <!-- ion-fab: ein schwebender Button, fixiert (slot="fixed") unten rechts,
       über der scrollenden Liste -->
  <ion-fab slot="fixed" vertical="bottom" horizontal="end">
    <ion-button shape="round" size="large" class="extended-fab" (click)="add()">
      <ion-icon slot="start" name="add" />
      {{ t(c().add) }}
    </ion-button>
  </ion-fab>
</ion-content>
  • Zeilen 9–28: eine Karte pro Person: ihre Initialen in einem Kreis, ihr Name, ihr Login und ihre beiden Schaltflächen. Eine Tabelle mit fünf Spalten, wie die der Web-Clients, würde auf einem Telefon nicht passen. [@empty]: was ein [@for] bei einer leeren Tabelle anzeigt;
  • Zeilen 36–41: [ion-fab]: eine schwebende Schaltfläche, unten rechts verankert ([slot="fixed"]: Sie scrollt nicht mit der Liste), „+ Arzt hinzufügen“. Der [FloatingActionButton.extended] von [Flutter] (ein Icon und Text) hat in [Ionic] kein fertiges Äquivalent ([ion-fab-button] ist rund, nur für ein Icon): Eine normale abgerundete Schaltfläche wird in [ion-fab] platziert.

11.13.9. src/app/pages/persons.scss

// =========================================================================
// persons.scss - die Stile der Liste der Ärzte oder der Clients
// =========================================================================

ion-card {
  margin: 0 0 10px;
}

// die Initialen, in einem farbigen Kreis
.initials {
  width: 44px;
  height: 44px;
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #dde3fb;
  color: var(--ion-color-primary);
  font-weight: 500;
}

.login {
  font-family: 'Roboto Mono', monospace;
}

// etwas Platz unten, um die letzte Zeile nicht unter der schwebenden Schaltfläche zu verdecken
ion-content {
  --padding-bottom: 96px;
}

// eine "erweiterte" schwebende Schaltfläche: Symbol und Text auf hellem Hintergrund
.extended-fab {
  --background: #dde3fb;
  --color: var(--ion-color-primary);
  --border-radius: 16px;
  text-transform: none;
}

Die Initialen in einem Kreis, der Login-Text in einer Festbreitenschrift, Abstand unterhalb der Liste (Zeilen 27–29: andernfalls würde die schwebende Schaltfläche die letzte Karte verdecken) und die „erweiterte“ schwebende Schaltfläche.

11.13.10. src/app/pages/person-form.ts

// =========================================================================
// src/app/pages/person-form.ts - Anlegen ODER Ändern eines
// Arztes oder eines Clients (ADMIN)
// -------------------------------------------------------------------------
//     /doctors/add               -> Anlegen (keine id)
//     /doctors/3/edit            -> Ändern (id = 3)
// (und dieselben Adressen unter /clients).
//
// Bei einer Änderung liest der Bildschirm zuerst den Datensatz; das Formular wird erst
// angezeigt, wenn der Datensatz gelesen wurde, und BEGINNT mit dessen Werten (ein
// linkedSignal, ohne sie später kopieren zu müssen).
// Hier wird keine Regel geprüft: Der Server validiert alles, und seine Fehler
// werden unter den Feldern angezeigt (siehe components/form-submission.ts).
// Die mit dem Datensatz gelesene VERSION geht mit der Änderung zurück: Hat ein anderer
// ADMIN ihn in der Zwischenzeit geändert, antwortet der Server mit 409 CONCURRENT_UPDATE.
// =========================================================================

import { Component, computed, effect, inject, input, linkedSignal, resource, untracked } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, IonSpinner } from '@ionic/angular';
import { ApiError } from '../api/api-error';
import { Data, RdvMedecinsApi, PersonType } from '../api/rdvmedecins-api';
import { positiveInteger } from '../app.routes';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { FormSubmission } from '../components/form-submission';
import { Cache } from '../state/cache';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';
import { keys, messageParams } from './persons-config';

const empty: Data = { title: 'Mr', firstName: '', lastName: '', login: '', password: '' };

@Component({
  selector: 'app-person-form',
  imports: [IonContent, IonButton, IonSpinner, InputField, PersonFields],
  templateUrl: './person-form.html',
})
export class PersonFormPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  readonly t = inject(Translations).t;
  readonly submission = new FormSubmission(this.messages);

  // der Typ: die Eigenschaft data der Route; die id: der Parameter :id der
  // Adresse (fehlt beim Anlegen; ihre Gültigkeit prüft die Route)
  readonly type = input.required<PersonType>();
  readonly id = input<string>();
  readonly recordId = computed(() => positiveInteger(this.id()));
  readonly creating = computed(() => this.recordId() === undefined);
  readonly c = computed(() => keys(this.type()));

  // Änderung: Der Datensatz wird gelesen (samt Version), OHNE Cache: Er
  // muss aktuell sein (sonst würde das Formular mit einer veralteten
  // Version beginnen: 409 CONCURRENT_UPDATE)
  readonly record = resource({
    params: () => {
      const id = this.recordId();
      return id === undefined ? undefined : { type: this.type(), id };
    },
    loader: ({ params: { type, id } }) => this.api.read(type, id),
  });

  // eine änderbare KOPIE der Startwerte (der gelesene Datensatz oder leer)
  readonly form = linkedSignal<Data>(() => {
    if (!this.record.hasValue()) return { ...empty };
    const p = this.record.value();
    return { title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', password: '', version: p.version };
  });

  // das Formular wird beim Anlegen angezeigt oder sobald der Datensatz gelesen wurde
  readonly ready = computed(() => this.creating() || this.record.hasValue());

  constructor() {
    // Datensatz, der nicht existiert (in der Zwischenzeit gelöscht ...): zurück zur Liste
    effect(() => {
      const e = this.record.error();
      if (e instanceof ApiError) {
        untracked(() => {
          this.messages.flash({ success: false, key: e.key, params: e.params });
          void this.router.navigateByUrl(`/${this.type()}`);
        });
      }
    });
  }

  text(field: string): string {
    return String(this.form()[field] ?? '');
  }

  update(field: string, value: string): void {
    this.form.update((f) => ({ ...f, [field]: value }));
    this.submission.clearError(field);
  }

  back(): void {
    void this.router.navigateByUrl(`/${this.type()}`);
  }

  async save(): Promise<void> {
    const type = this.type();
    const c = this.c();
    const id = this.recordId();
    const succeeded = await this.submission.submit(async () => {
      const p = id === undefined
        ? await this.api.add(type, this.form())
        : await this.api.edit(type, id, this.form());
      this.messages.flash({ key: this.creating() ? c.added : c.edited, params: messageParams(p) });
    });
    const key = this.messages.error()?.key;
    if (succeeded) {
      this.cache.invalidate(type); // die Liste hat sich geändert
      this.back();
    } else if (key === c.notFound) {
      // in der Zwischenzeit von einem anderen ADMIN gelöscht: zurück zur Liste
      this.messages.flash({ success: false, key });
      this.back();
    }
  }
}

Hinzufügen oder Bearbeiten eines Arztes oder eines Clients.

  • Zeilen 49–53: der Typ ([data] der Route) und die Kennung (der Parameter [:id] der Adresse, der beim Hinzufügen fehlt);
  • Zeilen 58–64: Bei einer Änderung wird der Datensatz OHNE den Cache gelesen: Er muss aktuell sein. Beim Hinzufügen ist [params] gleich [undefined]: Es gibt nichts zu lesen;
  • Zeilen 67–71: Die Eingabe BEGINNT mit den Werten des Datensatzes (oder mit leeren Werten), sobald der Datensatz gelesen wurde: ein weiteres [linkedSignal]. Der Client [Flutter] erreichte dies mit zwei Widgets (das zweite wurde erzeugt, nachdem der Datensatz gelesen worden war);
  • Zeile 74: Das Formular wird nur bei der Erstellung oder nach dem Lesen des Datensatzes angezeigt;
  • Zeilen 78–86: ein nicht gefundener Datensatz (inzwischen gelöscht): Rückkehr zur Liste, mit einer Meldung;
  • Zeilen 102–121: das Speichern des Datensatzes: [POST] oder [PUT], je nachdem, ob eine ID vorhanden ist. Die Erfolgsmeldung ist eine Flash-Meldung: Sie erscheint in der Liste. Wurde ein Datensatz inzwischen von einem anderen ADMIN gelöscht: Rückkehr zur Liste.

11.13.11. src/app/pages/person-form.html

<!-- ======================================================================
     person-form.html - Erstellen oder Aktualisieren einer Person
     ====================================================================== -->

<ion-content class="ion-padding">
  <h1>{{ t(creating() ? c().add : c().edit) }}</h1>

  @if (ready()) {
    <app-person-fields
      [values]="form()"
      [errors]="submission.errors()"
      (fieldChange)="update($event.field, $event.value)"
    />

    <h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
    <app-input-field
      label="PERSONS.LOGIN_LABEL"
      [maxLength]="30"
      [value]="text('login')"
      (valueChange)="update('login', $event)"
      [error]="submission.errors()['login']"
      [help]="creating() ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT'"
    />
    <!-- niemals vorausgefüllt: Das Passwort kommt nie vom Server zurück -->
    <app-input-field
      label="PERSONS.PASSWORD_LABEL"
      [secret]="true"
      [maxLength]="72"
      [value]="text('password')"
      (valueChange)="update('password', $event)"
      [error]="submission.errors()['password']"
      [params]="submission.params()"
      [help]="creating() ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'"
    />

    <div class="buttons">
      <ion-button shape="round" [disabled]="submission.inProgress()" (click)="save()">
        {{ t('PERSONS.SAVE') }}
      </ion-button>
      <ion-button shape="round" fill="outline" (click)="back()">{{ t('PERSONS.BACK') }}</ion-button>
    </div>
  } @else {
    <div class="ion-text-center ion-padding"><ion-spinner /></div>
  }
</ion-content>
  • Zeilen 9–13: die Identitätsfelder (siehe [person-fields.ts]);
  • Zeilen 16–34: der Benutzername und das Passwort, mit unterschiedlichen Hinweisen für Erstellung und Änderung (ein leer gelassenes Passwortfeld ändert das Passwort nicht). Das Passwort wird nie vorausgefüllt: Der Server gibt es nie zurück. [params]: Parameter der Passwort-Fehlermeldung ([{{min}}] ...).

11.13.12. src/app/pages/register.ts

// =========================================================================
// src/app/pages/register.ts - "Patientenkonto anlegen" (/register)
// -------------------------------------------------------------------------
// Hierher gelangt man erst, nachdem man das CAPTCHA des Anmeldebildschirms abgetippt hat
// (Schaltfläche "Patientenkonto anlegen"): Der Server hat dann einen
// Pass (ein Cookie) ausgestellt, den der Guard der Route geprüft hat (siehe
// app.routes.ts). Dieselben Felder wie im Formular des ADMIN, aber Login
// und Passwort sind Pflicht, mit Bestätigung.
// =========================================================================

import { Component, computed, inject, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';
import { Data, RdvMedecinsApi } from '../api/rdvmedecins-api';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { FormSubmission } from '../components/form-submission';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';

// Mindestlänge eines von einem Patienten gewählten Passworts: derselbe Wert
// wie beim Server (der bei dem Fehler PASSWORD_TOO_SHORT auch {min} zurücksendet)
const minPassword = '6';

@Component({
  selector: 'app-register',
  imports: [IonContent, IonButton, InputField, PersonFields],
  templateUrl: './register.html',
})
export class RegisterPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  readonly t = inject(Translations).t;
  readonly submission = new FormSubmission(this.messages);

  readonly form = signal<Data>({
    title: 'Mr',
    firstName: '',
    lastName: '',
    login: '',
    password: '',
    confirmation: '',
  });

  // die Parameter der Hilfemeldung UND der Passwortfehler
  readonly passwordParams = computed(() => ({ min: minPassword, ...this.submission.params() }));

  text(field: string): string {
    return String(this.form()[field] ?? '');
  }

  update(field: string, value: string): void {
    this.form.update((f) => ({ ...f, [field]: value }));
    this.submission.clearError(field);
  }

  backToLogin(): void {
    void this.router.navigateByUrl('/login');
  }

  async create(): Promise<void> {
    let login = '';
    const succeeded = await this.submission.submit(async () => {
      login = await this.api.register(this.form());
    });
    if (succeeded) {
      // zurück zum Anmeldebildschirm, Login vorausgefüllt
      this.messages.flash({ key: 'REGISTRATION.DONE', params: { login } });
      void this.router.navigate(['/login'], { queryParams: { login } });
    } else if (this.messages.error()?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
      // Pass abgelaufen (15 Minuten): zurück zum CAPTCHA
      this.messages.flash({ success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT' });
      this.backToLogin();
    }
  }
}

Erstellung eines Patientenkontos, zugänglich mit dem vom Anmeldescreen ausgestellten Passierschein (siehe [registrationGuard] in [app.routes.ts]).

  • Zeile 23: die minimale Passwortlänge; für die Hilfemeldung: derselbe Wert wie auf dem Server (der ihn auch mit dem Fehler [PASSWORD_TOO_SHORT] zurückgibt);
  • Zeile 47: Die Parameter für die Hilfemeldung und den Passwortfehler ([{{min}}]): Die Parameter des Servers haben, falls vorhanden, Vorrang;
  • Zeilen 62–76: die Erstellung. Bei Erfolg: Rückkehr zum Anmeldescreen mit vorausgefülltem Benutzernamen ([/login?login=...]: [queryParams] erstellt den Parameter), zusammen mit einer Flash-Meldung. Bei Misserfolg, weil der Passierschein abgelaufen ist (15 Minuten): Rückkehr zum CAPTCHA. Alle anderen Fehler bleiben unterhalb der Felder angezeigt.

11.13.13. src/app/pages/register.html

<!-- ======================================================================
     register.html - "Create a patient account"
     ====================================================================== -->

<ion-content class="ion-padding">
  <h1>{{ t('REGISTRATION.TITLE') }}</h1>
  <p class="intro">{{ t('REGISTRATION.INTRO') }}</p>

  <app-person-fields
    [values]="form()"
    [errors]="submission.errors()"
    (fieldChange)="update($event.field, $event.value)"
  />

  <h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
  <app-input-field
    label="PERSONS.LOGIN_LABEL"
    autocomplete="username"
    [maxLength]="30"
    [value]="text('login')"
    (valueChange)="update('login', $event)"
    [error]="submission.errors()['login']"
    help="REGISTRATION.LOGIN_HELP"
  />
  <app-input-field
    label="PERSONS.PASSWORD_LABEL"
    autocomplete="new-password"
    [secret]="true"
    [maxLength]="72"
    [value]="text('password')"
    (valueChange)="update('password', $event)"
    [error]="submission.errors()['password']"
    [params]="passwordParams()"
    help="REGISTRATION.PASSWORD_HELP"
  />
  <app-input-field
    label="ACCOUNT.CONFIRMATION_LABEL"
    autocomplete="new-password"
    [secret]="true"
    [maxLength]="72"
    [value]="text('confirmation')"
    (valueChange)="update('confirmation', $event)"
    [error]="submission.errors()['confirmation']"
  />

  <div class="buttons">
    <ion-button shape="round" [disabled]="submission.inProgress()" (click)="create()">
      {{ t('REGISTRATION.SUBMIT') }}
    </ion-button>
    <ion-button shape="round" fill="outline" (click)="backToLogin()">
      {{ t('REGISTRATION.BACK_TO_LOGIN') }}
    </ion-button>
  </div>
</ion-content>
  • Zeilen 16–44: ein NEUES Konto: [autocomplete="new-password"] veranlasst den Passwortmanager, ein sicheres Passwort vorzuschlagen und zu speichern.

11.13.14. src/app/pages/patient-area.ts

// =========================================================================
// src/app/pages/patient-area.ts - "Mein Bereich" (/my-area, Rolle USER)
// -------------------------------------------------------------------------
// Der Startbildschirm des Patienten, direkt nach der Anmeldung:
//   - zwei Optionen: [Mein Konto verwalten] und [Terminkalender anzeigen];
//   - sein bevorstehender Termin, falls vorhanden, mit der Möglichkeit, ihn zu stornieren.
// =========================================================================

import { Component, inject, resource } from '@angular/core';
import { Router } from '@angular/router';
import {
  IonButton, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonContent, IonIcon, IonItem, IonLabel,
  IonSpinner,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { calendar, personCircle } from 'ionicons/icons';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { label, Appointment } from '../api/types';
import { Confirmation } from '../components/confirmation';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { timeRange, longDay } from '../formatting';
import { Translations } from '../i18n/translations';
import { scheduleUrl } from './schedule';

@Component({
  selector: 'app-patient-area',
  imports: [
    IonContent, IonCard, IonCardHeader, IonCardTitle, IonCardContent, IonItem, IonLabel, IonIcon, IonButton,
    IonSpinner,
  ],
  templateUrl: './patient-area.html',
  styleUrl: './patient-area.scss',
})
export class PatientAreaPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  private readonly confirmation = inject(Confirmation);
  private readonly translations = inject(Translations);
  readonly t = this.translations.t;
  readonly label = label;
  readonly timeRange = timeRange;

  readonly area = resource({
    loader: () => this.cache.read('my-area', () => this.api.myArea()),
  });

  constructor() {
    addIcons({ calendar, personCircle });
    reloadAfterInvalidation(this.area);
    reportErrors(this.area);
  }

  // "Montag, 5. Oktober 2026, 8:00 - 8:20"
  when(a: Appointment): string {
    return `${longDay(a.day, this.translations.language())}, ${timeRange(a.slot)}`;
  }

  goTo(url: string): void {
    void this.router.navigateByUrl(url);
  }

  // der Terminkalender des Arztes an diesem Tag: Der Patient sieht darin seinen Namen
  seeInSchedule(a: Appointment): void {
    this.goTo(scheduleUrl(a.doctor.id, a.day));
  }

  async cancel(appointmentId: number): Promise<void> {
    if (!(await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM'))) return;
    try {
      await this.api.cancelAppointment(appointmentId);
      this.messages.showSuccess('SCHEDULE.CANCELLED');
    } catch (e) {
      this.messages.showApiError(e);
    }
    // der Bereich UND die Terminkalender haben sich geändert (der Bereich wird erneut gelesen: reloadAfterInvalidation)
    this.cache.invalidate('my-area');
    this.cache.invalidate('schedule');
  }
}

Der Patientenbereich: zwei Optionen und der anstehende Termin des Patienten.

  • Zeilen 46–48: das Dashboard des Patienten, aus dem Cache;
  • Zeilen 57–59: „Dienstag, 13. Oktober 2026, 8:00–8:20 Uhr“;
  • Zeilen 66–68: der Terminkalender des Arztes für diesen Tag: Der Patient sieht dort seinen Namen;
  • Zeilen 70–81: Stornierung des Termins des Patienten: Der Bereich UND die Terminkalender haben sich geändert.

11.13.15. src/app/pages/patient-area.html

<!-- ======================================================================
     patient-area.html - "My area"
     ====================================================================== -->

<ion-content class="ion-padding">
  @if (area.hasValue()) {
    @let e = area.value();
    <h1>{{ t('AREA.HELLO', { name: label(e.patient) }) }}</h1>

    <!-- zwei Options-"Karten", die berührt werden, um einen Bildschirm zu öffnen;
         detail: der Pfeil > rechts -->
    <ion-card>
      <ion-item [button]="true" [detail]="true" lines="none" (click)="goTo('/my-account')">
        <ion-icon slot="start" name="person-circle" color="primary" />
        <ion-label class="ion-text-wrap">
          <h2>{{ t('AREA.MANAGE_ACCOUNT') }}</h2>
          <p>{{ t('AREA.MANAGE_ACCOUNT_HELP') }}</p>
        </ion-label>
      </ion-item>
    </ion-card>
    <ion-card>
      <ion-item [button]="true" [detail]="true" lines="none" (click)="goTo('/schedule')">
        <ion-icon slot="start" name="calendar" color="primary" />
        <ion-label class="ion-text-wrap">
          <h2>{{ t('AREA.VIEW_SCHEDULE') }}</h2>
          <p>{{ t('AREA.VIEW_SCHEDULE_HELP') }}</p>
        </ion-label>
      </ion-item>
    </ion-card>

    <ion-card>
      <ion-card-header>
        <ion-card-title>{{ t('AREA.MY_APPOINTMENT') }}</ion-card-title>
      </ion-card-header>
      <ion-card-content>
        <!-- normalerweise nur einer (Regel "ein bevorstehender Termin gleichzeitig"),
             aber der Bildschirm kann mehrere anzeigen -->
        @for (a of e.appointments; track a.id) {
          <div class="when">{{ when(a) }}</div>
          <div>{{ label(a.doctor) }}</div>
          <div class="buttons">
            <ion-button fill="clear" (click)="seeInSchedule(a)">{{ t('AREA.SEE_IN_SCHEDULE') }}</ion-button>
            <ion-button fill="outline" shape="round" color="danger" (click)="cancel(a.id)">
              {{ t('AREA.CANCEL_APPOINTMENT') }}
            </ion-button>
          </div>
        } @empty {
          <p class="none">{{ t('AREA.NO_APPOINTMENT') }}</p>
        }
      </ion-card-content>
    </ion-card>
  } @else if (area.isLoading()) {
    <div class="ion-text-center ion-padding"><ion-spinner /></div>
  }
</ion-content>
  • Zeile 7: [@let]: eine Template-Variable, um die Wiederholung von [area.value()] zu vermeiden;
  • Zeilen 12–29: zwei Optionen: Karten, auf die man tippt, um einen Screen zu öffnen. [ion-item] und [button] reagieren auf Berührung; [detail] fügt rechts den Pfeil > hinzu;
  • Zeilen 38–49: der Termin und zwei Schaltflächen: den Terminkalender des Arztes für diesen Tag anzeigen, stornieren; oder, wenn es keinen Termin gibt ([@empty]), eine Meldung.

11.13.16. src/app/pages/patient-area.scss

// =========================================================================
// patient-area.scss - die Stile von "Mein Bereich"
// =========================================================================

ion-card {
  margin: 0 0 12px;
}

// die Symbole der Optionen, größer
ion-item ion-icon[slot='start'] {
  font-size: 32px;
}

ion-item h2 {
  font-weight: 500;
}

ion-card-title {
  font-size: 19px;
}

.when {
  font-weight: 600;
  color: var(--ion-text-color, #000);
}

.none {
  color: var(--ion-color-medium);
}

Karten ohne seitliche Ränder (der Screen hat bereits eigene), größere Icons für die Optionen und das Datum des Termins in Fettschrift.

11.13.17. src/app/pages/my-account.ts

// =========================================================================
// src/app/pages/my-account.ts - "Mein Konto verwalten" (/my-account, Rolle USER)
// -------------------------------------------------------------------------
// Zwei voneinander unabhängige Formulare:
//   1. die Änderung (Identität, Login, optionales neues Passwort);
//   2. das Löschen des Kontos - das auch seine Termine storniert.
// Beide verlangen das AKTUELLE Passwort (vom Server geprüft).
// Zwei Formulare, daher zwei FormSubmission (zwei Mengen von Fehlern). Wie
// beim Personenformular wird die Änderung erst angezeigt, wenn
// das Konto gelesen wurde, und beginnt mit dessen Werten.
// =========================================================================

import { Component, inject, linkedSignal, resource, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonCard, IonCardContent, IonContent, IonSpinner } from '@ionic/angular';
import { Data, RdvMedecinsApi } from '../api/rdvmedecins-api';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { Confirmation } from '../components/confirmation';
import { FormSubmission } from '../components/form-submission';
import { Cache } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { Session } from '../state/session';
import { Translations } from '../i18n/translations';

@Component({
  selector: 'app-my-account',
  imports: [IonContent, IonCard, IonCardContent, IonButton, IonSpinner, InputField, PersonFields],
  templateUrl: './my-account.html',
  styleUrl: './my-account.scss',
})
export class MyAccountPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly session = inject(Session);
  private readonly cache = inject(Cache);
  private readonly messages = inject(Messages);
  private readonly router = inject(Router);
  private readonly confirmation = inject(Confirmation);
  readonly t = inject(Translations).t;

  // ==================================================== 1. die Änderung
  // bei jedem Besuch erneut gelesen, ohne Cache: Seine Version muss aktuell sein
  readonly account = resource({ loader: () => this.api.myAccount() });
  readonly editing = new FormSubmission(this.messages);
  readonly form = linkedSignal<Data>(() => {
    if (!this.account.hasValue()) return {};
    const a = this.account.value();
    return {
      title: a.title,
      firstName: a.firstName,
      lastName: a.lastName,
      login: a.login,
      password: '',
      confirmation: '',
      currentPassword: '',
      version: a.version,
    };
  });

  // ==================================================== 2. das Löschen
  readonly deletion = new FormSubmission(this.messages);
  readonly deletePassword = signal('');

  constructor() {
    reportErrors(this.account);
  }

  text(field: string): string {
    return String(this.form()[field] ?? '');
  }

  update(field: string, value: string): void {
    this.form.update((f) => ({ ...f, [field]: value }));
    this.editing.clearError(field);
  }

  back(): void {
    void this.router.navigateByUrl('/my-area');
  }

  async save(): Promise<void> {
    const succeeded = await this.editing.submit(async () => {
      // der Server hat einen NEUEN Token ausgestellt (Name, Login): Die obere Leiste muss folgen
      this.session.update(await this.api.editMyAccount(this.form()));
      this.messages.flash({ key: 'MY_ACCOUNT.UPDATED' });
    });
    if (succeeded) {
      this.cache.invalidate('my-area');
      this.back();
    } else {
      // niemals ein im Feld verbliebenes Passwort nach einem abgelehnten Senden;
      // der Wert wird geändert, OHNE über update() zu gehen, um nicht
      // den Fehler zu löschen, den der Server gerade daran angehängt hat
      this.form.update((f) => ({ ...f, currentPassword: '' }));
    }
  }

  changeDeletePassword(value: string): void {
    this.deletePassword.set(value);
    this.deletion.clearError('currentPassword');
  }

  async deleteAccount(): Promise<void> {
    if (!(await this.confirmation.ask('MY_ACCOUNT.DELETE_CONFIRM'))) return;
    const succeeded = await this.deletion.submit(() => this.api.deleteMyAccount(this.deletePassword()));
    if (succeeded) {
      // zuerst die Meldung: Sie wird auf dem Anmeldebildschirm angezeigt, wohin uns
      // die Guards führen, sobald die Sitzung leer ist
      this.messages.flash({ key: 'MY_ACCOUNT.DELETED' });
      this.session.forget(true); // der Server hat das Token-Cookie gelöscht
    }
  }
}

„Mein Konto verwalten“: zwei getrennte Formulare, jedes mit seinem eigenen [FormSubmission].

  • Zeile 43: das Konto, bei jedem Besuch ohne Cache neu gelesen (seine Version muss aktuell sein);
  • Zeilen 45–58: Die Eingabe beginnt mit den Werten des Kontos, sobald das Konto gelesen wurde;
  • Zeilen 81–96: die Bearbeitung. Der Server gibt den Benutzer mit den aktualisierten Informationen zurück (und ein neues Token in seinem Cookie): Die Sitzung wird aktualisiert, und der im Menü angezeigte Name wird entsprechend aktualisiert. Nach einer fehlgeschlagenen Anmeldung wird das aktuelle Passwort aus dem Feld geleert, ohne die Fehlermeldung zu löschen, die der Server ihm soeben zugeordnet hat;
  • Zeilen 103–112: Löschen des Kontos, nach Bestätigung. Zuerst die Meldung (eine Flash-Meldung); dann wird die Sitzung geleert, und die Guards zeigen den Anmeldescreen zusammen mit der Meldung an.

11.13.18. src/app/pages/my-account.html

<!-- ======================================================================
     my-account.html - "Manage my account"
     ====================================================================== -->

<ion-content class="ion-padding">
  <!-- 1. die Änderung -->
  <ion-card>
    <ion-card-content>
      <h1>{{ t('MY_ACCOUNT.TITLE') }}</h1>
      @if (account.hasValue()) {
        <app-person-fields
          [values]="form()"
          [errors]="editing.errors()"
          (fieldChange)="update($event.field, $event.value)"
        />
        <h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
        <app-input-field
          label="PERSONS.LOGIN_LABEL"
          autocomplete="username"
          [maxLength]="30"
          [value]="text('login')"
          (valueChange)="update('login', $event)"
          [error]="editing.errors()['login']"
        />
        <app-input-field
          label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
          autocomplete="new-password"
          [secret]="true"
          [maxLength]="72"
          [value]="text('password')"
          (valueChange)="update('password', $event)"
          [error]="editing.errors()['password']"
          [params]="editing.params()"
          help="PERSONS.PASSWORD_HELP_EDIT"
        />
        <app-input-field
          label="ACCOUNT.CONFIRMATION_LABEL"
          autocomplete="new-password"
          [secret]="true"
          [maxLength]="72"
          [value]="text('confirmation')"
          (valueChange)="update('confirmation', $event)"
          [error]="editing.errors()['confirmation']"
        />
        <app-input-field
          label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
          autocomplete="current-password"
          [secret]="true"
          [maxLength]="72"
          [value]="text('currentPassword')"
          (valueChange)="update('currentPassword', $event)"
          [error]="editing.errors()['currentPassword']"
          help="MY_ACCOUNT.CURRENT_PASSWORD_HELP"
        />
        <div class="buttons">
          <ion-button shape="round" [disabled]="editing.inProgress()" (click)="save()">
            {{ t('PERSONS.SAVE') }}
          </ion-button>
          <ion-button shape="round" fill="outline" (click)="back()">{{ t('MY_ACCOUNT.BACK') }}</ion-button>
        </div>
      } @else {
        <div class="ion-text-center ion-padding"><ion-spinner /></div>
      }
    </ion-card-content>
  </ion-card>

  <!-- 2. das Löschen: ein Formular mit einem einzigen Feld -->
  <ion-card class="danger">
    <ion-card-content>
      <h1>{{ t('MY_ACCOUNT.DELETE_TITLE') }}</h1>
      <p class="help">{{ t('MY_ACCOUNT.DELETE_HELP') }}</p>
      <app-input-field
        label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
        autocomplete="current-password"
        [secret]="true"
        [maxLength]="72"
        [value]="deletePassword()"
        (valueChange)="changeDeletePassword($event)"
        [error]="deletion.errors()['currentPassword']"
      />
      <ion-button shape="round" color="danger" [disabled]="deletion.inProgress()" (click)="deleteAccount()">
        {{ t('MY_ACCOUNT.DELETE_SUBMIT') }}
      </ion-button>
    </ion-card-content>
  </ion-card>
</ion-content>
  • Zeilen 7–65: die Bearbeitung in einer Karte; das Formular erscheint erst, nachdem das Konto gelesen wurde;
  • Zeilen 68–85: das Löschen, in einer Karte mit rotem Rand: ein Formular mit einem einzigen Feld.

11.13.19. src/app/pages/my-account.scss

// =========================================================================
// my-account.scss - die Stile von "Mein Konto verwalten"
// =========================================================================

ion-card {
  margin: 0 0 12px;
}

ion-card-content {
  color: var(--ion-text-color, #000);

  // die Titel, wie anderswo (Ionic gibt ihnen in einer Card andere Abstände)
  h1 {
    font-size: 26px;
    margin: 8px 0 16px;
  }

  h3 {
    font-size: 15px;
    font-weight: 500;
    margin: 16px 0 12px;
  }
}

// die Karte zum Löschen: ein roter Rahmen, ein roter Titel
ion-card.danger {
  border: 1px solid #e57373;

  h1 {
    color: #d32f2f;
  }
}

Die Titel in den Karten ([Ionic] gibt ihnen in einem [ion-card-content] unterschiedliche Größen und Abstände) und der rote Rand für das Löschen.

11.13.20. src/app/pages/error-page.ts

// =========================================================================
// src/app/pages/error-page.ts - der Fehlerbildschirm: 404 (unbekannte Adresse)
// oder 403 (unzureichende Rolle, siehe app.routes.ts)
// -------------------------------------------------------------------------
// Der Code (403 oder 404) wird von der Eigenschaft data der Route geliefert.
// =========================================================================

import { Component, inject, input } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';
import { Translations } from '../i18n/translations';

@Component({
  selector: 'app-error-page',
  imports: [IonContent, IonButton],
  templateUrl: './error-page.html',
  styles: `
    .error {
      color: #d32f2f;
    }
  `,
})
export class ErrorPage {
  private readonly router = inject(Router);
  readonly t = inject(Translations).t;
  readonly code = input(404);

  // "/": Der Guard leitet zur Startseite der Rolle (oder zur Anmeldung) um
  home(): void {
    void this.router.navigateByUrl('/');
  }
}
1
2
3
4
5
6
7
8
9
<!-- ======================================================================
     error-page.html - der Fehlerbildschirm (403, 404)
     ====================================================================== -->

<ion-content class="ion-padding">
  <h1 class="error">{{ t('ERROR_PAGE.TITLE') }} {{ code() }}</h1>
  <p>{{ t(code() === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND') }}</p>
  <ion-button shape="round" (click)="home()">{{ t('ERROR_PAGE.BACK') }}</ion-button>
</ion-content>

Die Fehlerseite: 404 (unbekannte Adresse) oder 403 (unzureichende Berechtigungen). Der Code ist die Route-Eigenschaft [data], die am Einstiegspunkt [code] zugewiesen wird (Zeile 26 von [error-page.ts]). „Zurück zur Startseite“ führt zu [/], das der Guard auf die Startseite der Rolle umleitet.

11.14. Flutter und Ionic: ein Vergleich

Beide Clients leisten genau dasselbe, mit derselben Architektur, Datei für Datei. Einige Unterschiede sind erwähnenswert:

  • das Token-Cookie: Der [Flutter]-Client musste es auf dem Telefon selbst verwalten (ein HTTP-Client, der [Set-Cookie] liest und [Cookie] schreibt); der Client [Ionic] stützt sich auf den Webbrowser und auf den nativen Code von [Android] ([CapacitorHttp]) auf dem Telefon;
  • Zustand und Aktualisierungen: Die [ChangeNotifier] -Signale von [Flutter] benachrichtigen ihre Beobachter ([notifyListeners()]), und die Widgets bauen sich neu auf; die Signale von [Angular] wissen, WER sie liest, und aktualisieren nur das, was von ihnen abhängt. Berechnete Signale ([computed]), verknüpfte Signale ([linkedSignal]) und Ressourcen ([resource]) ersetzen einen großen Teil von [initState], [didUpdateWidget] und [FutureBuilder];
  • Adresse: In beiden Fällen steckt der gesamte Zustand des Screens in der Adresse; der [Angular]-Router übergibt sie direkt an die Inputs der Komponente ([withComponentInputBinding]);
  • vorgefertigte Komponenten: [Ionic] stellt das dauerhafte Menü auf dem großen Bildschirm ([ion-split-pane]), die Fenster ([ion-modal], [ion-popover], [AlertController]) und den Kalender ([ion-datetime]) bereit; [Flutter] bringt seine eigenen mit ([NavigationRail], [showDatePicker] ...), aber das an die Adresse gebundene Buchungsfenster wurde dort von Hand gezeichnet;
  • Das Web: Der Client [Ionic] IST eine Webanwendung (auf Basis von HTML, einige hundert Kilobyte); der für das Web kompilierte [Flutter]-Client zeichnet jedes Pixel auf eine Canvas-Fläche und lädt zuerst seine Rendering-Engine herunter (einige Megabyte). Auf dem Telefon hingegen wird die [Flutter]-Anwendung in Maschinencode kompiliert, während die [Ionic]-Anwendung innerhalb der [WebView], der Browser-Engine, läuft.