Skip to content

6. Kapitel 5 - Der [Angular]-Client der Anwendung [RdvMedecins]

Dieses Kapitel beschreibt Datei für Datei den Inhalt des Ordners [rdvmedecins-angular-client], der diesem Dokument beiliegt, im durchgängig in diesem Kurs verwendeten Format: zeilenweise nummerierter Quellcode, gefolgt von einem Abschnitt mit dem Titel „Kommentieren wir diesen Code:“. Jeder Projektordner enthält außerdem eine eigene Datei README.md.

6.1. Architekturüberblick

Wie im ursprünglichen Dokument folgt der Client einer Schichtenarchitektur, die wir hier als V-C-Services (View-Controller-Services) bezeichnen:

Image

Ein Unterschied in der Terminologie verdient Beachtung: In AngularJS 1.x waren die View (das HTML-Template) und der Controller (die zugehörige JavaScript-Klasse) zwei getrennte Einheiten, die über $scope verbunden waren. In [Angular] sind sie in einer einzigen Einheit zusammengefasst, der Komponente (siehe vorheriges Kapitel) – deshalb sprechen wir im Folgenden einfach von „Komponenten“, wo das ursprüngliche Dokument zwischen View und Controller unterschied.

Wie im ursprünglichen Dokument kommunizieren Komponenten NIEMALS direkt mit dem Server: Diese Rolle ist ausschließlich der Service-Schicht vorbehalten. Dies ist ein Entwurfsprinzip, das für AngularJS 1.x und [Angular] gleichermaßen gilt – es hat sich nicht geändert.

6.2. Projektbaum

Image

Diese Struktur folgt direkt dem Ablauf des ursprünglichen Dokuments (Login, Auswahl von Arzt/Tag, Terminkalender anzeigen, Termin vereinbaren), hier lediglich in eigenständigen [Angular]-Komponenten organisiert statt in getrennten Controllern und Views von AngularJS 1.x.

Bootstrap wird in allen Views verwendet ([node_modules/bootstrap/dist/css/bootstrap.min.css], deklariert in angular.json) – eine direkte Weiterentwicklung von Bootstrap 3, das bereits im ursprünglichen Dokument verwendet wurde.

6.3. Konfigurationsdateien des Projekts

Image

6.3.1. package.json

{
  "name": "rdvmedecins-angular-client",
  "version": "0.0.0",
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
    "build": "ng build",
    "watch": "ng build --watch --configuration development",
    "test": "ng test"
  },
  "private": true,
  "packageManager": "npm@10.9.7",
  "dependencies": {
    "@angular/common": "^22.1.0",
    "@angular/compiler": "^22.1.0",
    "@angular/core": "^22.1.0",
    "@angular/forms": "^22.1.0",
    "@angular/platform-browser": "^22.1.0",
    "@angular/router": "^22.1.0",
    "@ngx-translate/core": "^18.0.0",
    "@ngx-translate/http-loader": "^18.0.0",
    "bootstrap": "^5.3.3",
    "rxjs": "~7.8.0",
    "tslib": "^2.3.0"
  },
  "devDependencies": {
    "@angular/build": "^22.1.0",
    "@angular/cli": "^22.1.0",
    "@angular/compiler-cli": "^22.1.0",
    "prettier": "^3.8.1",
    "typescript": "~6.0.0"
  }
}

Kommentieren wir diesen Code:

  • Zeilen 4–10: [“scripts”: { … }] – die verfügbaren Befehle `npm run <name>`. `start` (`ng serve`) startet den Entwicklungsserver mit automatischem Neuladen, sobald eine Quelldatei geändert wird – das ist der Befehl, der in diesem gesamten Dokument verwendet wird;
  • Zeilen 13–25: [“dependencies”: { … }] – die Pakete, die erforderlich sind, um die Anwendung im Browser auszuführen: der Kern von [Angular] ([@angular/core], [@angular/common], [@angular/compiler], [@angular/forms], [@angular/platform-browser], [@angular/router]), Bootstrap (nur das Stylesheet; siehe angular.json), RxJS (die von [HttpClient] verwendeten Observables) und – in diesem Kapitel eingeführt – [@ngx-translate/core] und [@ngx-translate/http-loader], die Drittanbieter-Bibliothek für die FR/EN-Übersetzung der Oberfläche (siehe [LanguageService] und app.config.ts weiter unten);
  • Zeilen 26–32: [“devDependencies”: { … }] – Pakete, die nur während der Entwicklung benötigt werden (CLI, Compiler) und nie im endgültigen, an den Browser ausgelieferten Bundle enthalten sind: @angular/cli/@angular/build (die CLI und ihre Kompilierungs-Engine), [@angular/compiler-cli] (Ahead-of-Time-Kompilierung der Templates), TypeScript und Prettier (automatische Code-Formatierung, in diesem Dokument nicht verwendet, aber standardmäßig in jedem generierten [Angular]-Projekt enthalten).

Anders als der [NestJS]-Server (Modul commonjs, siehe Kapitel 3) läuft ein [Angular]-Standardprojekt als native ECMAScript-Module (import/export) – das spiegelt sich weiter unten in "module": "preserve" in tsconfig.json wider.

6.3.2. angular.json

  {
    "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
    "version": 1,
    "cli": { "packageManager": "npm" },
    "newProjectRoot": "projects",
    "projects": {
      "rdvmedecins-angular-client": {
        "projectType": "application",
        "root": "",
       "sourceRoot": "src",
       "prefix": "app",
       "architect": {
         "build": {
           "builder": "@angular/build:application",
           "options": {
             "browser": "src/main.ts",
             "tsConfig": "tsconfig.app.json",
             "assets": [
               { "glob": "**/*", "input": "public" }
             ],
             "styles": [
               "node_modules/bootstrap/dist/css/bootstrap.min.css",
               "src/styles.css"
             ]
           },
           "configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
           "defaultConfiguration": "production"
         },
         "serve": {
           "builder": "@angular/build:dev-server",
           "configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
           "defaultConfiguration": "development"
         }
       }
     }
   }
 }

Kommentieren wir diesen Code (einige Zeilen wurden oben der Lesbarkeit halber gekürzt – die mitgelieferte Datei ist vollständig):

  • Zeile 11: [“prefix”: “app”,] – das Präfix, das auf den Selektor jeder Komponente des Projekts angewendet wird (app-login, app-schedule usw.) – eine vom Compiler durchgesetzte Konvention, die Namenskollisionen mit eventuellen Drittanbieter-Komponenten verhindert;
  • Zeile 16: [“browser”: “src/main.ts”,] – der Einstiegspunkt der Kompilierung – dieselbe Datei, die weiter unten in diesem Kapitel erklärt wird;
  • Zeilen 18–20: [“assets”: [ { “glob”: “**/*”, “input”: “public” } ],] – kopiert den gesamten Inhalt des Ordners public/ unverändert in das Wurzelverzeichnis der kompilierten Anwendung – dieser Mechanismus macht public/i18n/fr.json unter der URL /i18n/fr.json erreichbar, der Adresse, die TranslateHttpLoader abfragt (siehe weiter unten in diesem Kapitel);
  • Zeilen 21–24: [“styles”: [ “node_modules/bootstrap/dist/css/bootstrap.min.css”, “src/styles.css” ],] – die globalen Stylesheets, bei der Kompilierung in dieser Reihenfolge zusammengefügt: zuerst Bootstrap (damit unsere eigenen Regeln in [styles.css] es bei Bedarf überschreiben können), ohne eine herkömmliche @import-Anweisung für CSS zu verwenden.

Diese Datei hat im ursprünglichen AngularJS-1.x-Projekt kein Äquivalent (die damaligen Build-Werkzeuge – Grunt, Gulp – wurden separat konfiguriert); im [NestJS]-Projekt (Kapitel 3) erfüllt nest-cli.json einen ähnlichen Zweck, allerdings auf einfachere Weise.

6.3.3. [tsconfig.json]

  {
    "compileOnSave": false,
    "compilerOptions": {
      "strict": true,
      "noImplicitOverride": true,
      "noPropertyAccessFromIndexSignature": true,
      "noImplicitReturns": true,
      "noFallthroughCasesInSwitch": true,
      "skipLibCheck": true,
     "isolatedModules": true,
     "experimentalDecorators": true,
     "importHelpers": true,
     "target": "ES2022",
     "module": "preserve"
   },
   "angularCompilerOptions": {
     "enableI18nLegacyMessageIdFormat": false,
     "strictInjectionParameters": true,
     "strictInputAccessModifiers": true,
     "strictTemplates": true
   },
   "files": [],
   "references": [
     { "path": "./tsconfig.app.json" }
   ]
 }

Zerlegen wir diesen Code:

  • Zeile 4: [“strict”: true,] – anders als der [NestJS]-Server (der nur strictNullChecks isoliert aktiviert; siehe Kapitel 3) aktiviert der Client den vollständigen strikten Modus von TypeScript: Jede Variable muss einen bestimmbaren Typ haben, und jeder Wert null/undefined muss explizit behandelt werden. Das ist eine strengere Wahl, die dazu passt, dass dieses Dokument [Angular] als Maßstab für „aktuelle Best Practices“ darstellt;
  • Zeile 20: [“strictTemplates”: true]–die wichtigste Option in dieser Datei: Sie dehnt die Typprüfung von TypeScript auf die HTML-Templates selbst aus ([app.html], schedule.component.html …). Ein Fehler wie {{ doctor.lastNamee }} (Tippfehler) oder [canEdit]="auth.isAdmin" (fehlende Klammern) wird dann bei der Kompilierung gemeldet, genau wie ein Fehler in einer .ts-Datei – was in AngularJS 1.x (2014) nicht der Fall war, wo ein solches Template stets kompilierte und der Fehler erst zur Laufzeit sichtbar wurde (meist unbemerkt);
  • Zeilen 22–25: [“files”: [], “references”: [ { “path”: “./tsconfig.app.json” } ]] – diese Wurzeldatei kompiliert selbst keine Dateien ("files": []): Sie delegiert an tsconfig.app.json (unten) über den Mechanismus der TypeScript-Projektreferenzen, der es einem einzigen [Angular]-Projekt ermöglicht, am Ende mehrere getrennte Build-Konfigurationen (Anwendung, Tests usw.) zu definieren, die eine gemeinsame Grundlage teilen.

6.3.4. tsconfig.app.json

{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "outDir": "./out-tsc/app",
    "types": []
  },
  "include": [
    "src/**/*.ts"
  ],
  "exclude": [
    "src/**/*.spec.ts"
  ]
}

Kommentieren wir diesen Code:

  • Zeile 2: [“extends”: “./tsconfig.json”,] – baut auf der gemeinsamen Grundlage auf (strikter Modus, Target ES2022 …), statt alles neu zu definieren;
  • Zeile 8: [“src/**/*.ts”] – alle .ts-Dateien des Projekts, einschließlich (zum Beispiel) language.service.ts, das in diesem Kapitel hinzugefügt wurde;
  • Zeile 11: [“src/**/*.spec.ts”] – Unit-Test-Dateien (in diesem Projekt nicht vorhanden, aber per Konvention ausgeschlossen) werden separat mit ihrer eigenen Konfiguration kompiliert – in diesem Dokument nicht behandelt.

6.4. Start der Anwendung

Image

6.4.1. src/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>RdvMedecins - Angular client</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="favicon.ico">
</head>
<body>
  <app-root></app-root>
</body>
</html>

Kommentieren wir diesen Code:

  • Zeile 2: [<html lang="en">] – die Standardsprache der Seite, nützlich für Barrierefreiheit und Suchmaschinen. Da diese HTML-Seite statisch ist (sie wird vom Browser geladen, BEVOR die [Angular]-Anwendung startet), kann sie eine später vom Benutzer getroffene Sprachwahl naturgemäß nicht sofort widerspiegeln; es ist [LanguageService] (siehe unten), der dieses Attribut dynamisch aktualisiert, sobald der Benutzer auf Französisch umschaltet;
  • Zeile 11: [] – der Selektor der Wurzelkomponente ([App], siehe app.ts: selector: 'app-root'): Dies ist das einzige Element, das die Seite anfangs enthält, und [Angular] füllt es vollständig, sobald es gestartet ist. Das folgt genau demselben Prinzip wie in AngularJS 1.x (2014), das ng-app="rdvmedecinsApp" im Tag <html> der Datei [app.html] des ursprünglichen Projekts setzte – eine nahezu leere HTML-Seite, die vollständig vom JavaScript-Framework gesteuert wird.

6.4.2. [src/main.ts]

1
2
3
4
5
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { App } from './app/app';

bootstrapApplication(App, appConfig).catch((err) => console.error(err));

Kommentieren wir diesen Code:

  • Zeile 5: [bootstrapApplication(App, appConfig).catch((err) => console.error(err));] – startet die Anwendung, indem es die Wurzelkomponente ([App]) und ihre Konfiguration (appConfig; siehe app.config.ts weiter unten) angibt; bootstrapApplication ist die Startfunktion für eigenständige [Angular]-Anwendungen (ohne NgModule), die platformBrowserDynamic().bootstrapModule([AppModule]) aus älteren Versionen von Angular ersetzt. .catch(...) fängt alle Fehler ab, die beim Start selbst auftreten (bevor irgendeine Zeile des Anwendungscodes ausgeführt wird) – ein Szenario, das selten und schwerwiegend genug ist, um eine eigene Behandlung getrennt von der üblichen Fehlerbehandlung der Anwendung zu rechtfertigen.

Es gibt nur einen einzigen Einstiegspunkt für die gesamte Anwendung: Das ist genau die Definition einer Single-Page-Webanwendung (SPA), wie bereits im ursprünglichen Dokument beschrieben.

6.4.3. [src/styles.css]

body {
  background-color: #f5f7fa;
}

.free-slot {
  cursor: pointer;
}

.free-slot:hover {
  background-color: #e9f7ef;
}

Kommentieren wir diesen Code:

  • Zeile 1: [body { background-color: #f5f7fa; }] – ein sehr helles Grau statt des standardmäßigen reinen Weiß, damit sich die Bootstrap-Karten (weißer Hintergrund, .card) leicht vom Hintergrund der Seite abheben;
  • Zeilen 5–10: [.free-slot] – wird auf die Zeilen der Kalendertabelle angewandt, die einen verfügbaren Zeitslot darstellen (siehe schedule.component.html, [class.free-slot]="scheduleSlot.appointment === null"): Der Cursor wechselt zu einer Hand (cursor: pointer) und der Hintergrund wird beim Überfahren leicht grün, um anzudeuten, dass die Zeile anklickbar ist – noch bevor man sie anklickt.

Diese Datei enthält globale Stile, im Gegensatz zu den „lokalen“ Stilen in der Datei .css jeder Komponente (schedule.component.css …), die nur für das Template dieser einen Komponente gelten. src/app/app.css, das Stylesheet der Wurzelkomponente, bleibt leer: Bootstrap und [styles.css] genügen für alles, was in diesem Dokument umgesetzt wird.

6.5. Die Schicht core/models

Image

6.5.1. src/app/core/models/appointment.models.ts

  export interface ServerResponse<T> {
    status: number;
    data: T | null;
  }

  export interface Doctor {
    id: number;
    title: string;
    lastName: string;
   firstName: string;
 }

 export interface Client {
   id: number;
   title: string;
   lastName: string;
   firstName: string;
 }

 export interface SlotJson {
   id: number;
   startHour: number;
   startMinute: number;
   endHour: number;
   endMinute: number;
 }

 export interface AppointmentJson {
   id: number;
   day: string;
   client: Client | null;
   slot: SlotJson | null;
 }

 export interface ScheduleSlot {
   slot: SlotJson;
   appointment: AppointmentJson | null;
 }

 export interface DoctorDaySchedule {
   doctor: Doctor;
   day: string;
   slots: ScheduleSlot[];
 }

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

 export interface LoginResult {
   accessToken: string;
   login: string;
   name: string;
   role: Role;
 }

Kommentieren wir diesen Code:

  • Zeilen 1–4: [export interface ServerResponse { status: number; data: T | null; }] – entspricht exakt der Server-Klasse [ServerResponse]<T> (siehe Kapitel 3): Jede JSON-Antwort hat diese Form;
  • Zeilen 6–18: [Doctor / Client] – zwei Interfaces gleicher Form, die den [TypeORM]-Entitäten gleichen Namens entsprechen (Kapitel 3). Zur Erinnerung: [Client] bezeichnet hier einen Patienten, nicht einen „HTTP-Client“;
  • Zeilen 20–33: [SlotJson / AppointmentJson] – die „leichten“ Versionen, die serverseitig von getMapForSlot/getMapForAppointment erzeugt werden (Kapitel 3, static.helper.ts);
  • Zeilen 40–44: [export interface DoctorDaySchedule { … }] – entspricht der Antwort von GET /getDoctorScheduleOfDay/:doctorId/:day;
  • Zeile 46: [export type Role = ‘ADMIN’ | ‘USER’;] – eine exakte Kopie des Typs [Role] des Servers (src/entities/user.entity.ts);
  • Zeilen 48–53: [export interface LoginResult { … }] – das Format der Daten, die POST /login zurückgibt (siehe [AuthService] weiter unten), eine exakte Kopie des gleichnamigen Server-Interfaces (auth/login-result.model.ts).

In AngularJS 1.x (2014) erlaubte das ursprüngliche JavaScript es nicht, das erwartete Datenformat auf diese Weise zu beschreiben: Eine Serverantwort wurde als beliebiges Objekt behandelt, ohne dass vor der Ausführung irgendeine Validierung stattfand. Mit TypeScript wird ein Tippfehler in einem Feldnamen nun noch vor der Ausführung des Programms gemeldet – bei der Kompilierung.

6.6. Die Schicht core/services

Image

6.6.1. src/app/core/services/settings.service.ts

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

  @Injectable({ providedIn: 'root' })
  export class SettingsService {
    readonly apiBaseUrl = signal('http://localhost:8080');

    setApiBaseUrl(url: string): void {
      this.apiBaseUrl.set(url);
    }
 }

Kommentieren wir diesen Code:

  • Zeile 3: [@Injectable({ providedIn: 'root' })] – deklariert einen Service als globalen Singleton der Anwendung: [Angular] erzeugt automatisch eine einzige Instanz davon, sobald eine Komponente sie zum ersten Mal benötigt – das moderne Äquivalent eines Services, den AngularJS 1.x mit .service() oder .factory() deklarierte;
  • Zeile 5: [readonly apiBaseUrl = signal(‘http://localhost:8080’);] – signal(...) erzeugt einen reaktiven Wert: Jeder, der apiBaseUrl() in einem [Angular]-Template liest, wird automatisch benachrichtigt, wenn sich sein Wert ändert – der zentrale Reaktivitätsmechanismus des modernen [Angular], der die Beobachtung ($watch/$scope.$apply) von AngularJS 1.x ersetzt;
  • Zeilen 7–9: [setApiBaseUrl(url: string): void { this.apiBaseUrl.set(url); }] – übernommen aus dem Feld „URL auf dem Server“ in der Startansicht des ursprünglichen Dokuments, die es dem Benutzer bereits erlaubte, sie über die Oberfläche zu ändern (nützlich, wenn der Server auf einem anderen Port läuft).

6.6.2. src/app/core/services/appointment.service.ts

  import { Injectable, inject } from '@angular/core';
  import { HttpClient } from '@angular/common/http';
  import { Observable, map } from 'rxjs';
  import { SettingsService } from './settings.service';
  import { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';

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

   getAllDoctors(): Observable<Doctor[]> {
     return this.http
       .get<ServerResponse<Doctor[]>>(`${this.settings.apiBaseUrl()}/getAllDoctors`)
       .pipe(map((response) => this.extract(response)));
   }

   getAllClients(): Observable<Client[]> {
     return this.http
       .get<ServerResponse<Client[]>>(`${this.settings.apiBaseUrl()}/getAllClients`)
       .pipe(map((response) => this.extract(response)));
   }

   getDoctorScheduleOfDay(doctorId: number, day: string): Observable<DoctorDaySchedule> {
     return this.http
       .get<ServerResponse<DoctorDaySchedule>>(
         `${this.settings.apiBaseUrl()}/getDoctorScheduleOfDay/${doctorId}/${day}`,
       )
       .pipe(map((response) => this.extract(response)));
   }

   addAppointment(day: string, clientId: number, slotId: number): Observable<AppointmentJson> {
     return this.http
       .post<ServerResponse<AppointmentJson>>(`${this.settings.apiBaseUrl()}/addAppointment`, { day, clientId, slotId })
       .pipe(map((response) => this.extract(response)));
   }

   deleteAppointment(appointmentId: number): Observable<void> {
     return this.http
       .post<ServerResponse<null>>(`${this.settings.apiBaseUrl()}/deleteAppointment`, { appointmentId })
       .pipe(map(() => undefined));
   }

   private extract<T>(response: ServerResponse<T>): T {
     if (response.status !== 0) {
       throw new Error(`The server responded with error status ${response.status}`);
     }
     return response.data as T;
   }
 }

Kommentieren wir diesen Code:

  • Zeile 8: [export class AppointmentService {] – das direkte Äquivalent des DAO-Services, der im Kapitel „Beispiel 6: Die HTTP-Services“ des ursprünglichen Dokuments vorgestellt wurde (das den AngularJS-Service $http verwendete). Anders als bei einer herkömmlichen serverseitigen Anwendung, bei der die Web-Schicht nur über die Geschäftsschicht mit der DAO-Schicht kommuniziert, erlaubt der Client der Präsentationsschicht (unseren Komponenten), diesen Service direkt aufzurufen – es gibt clientseitig keine eigene „Geschäftsschicht“;
  • Zeile 9: [private readonly http = inject(HttpClient);] – `inject()` ist die moderne Art, in [Angular] eine Abhängigkeit zu beziehen (es ersetzt die klassische Konstruktorinjektion);
  • Zeilen 12–16: [getAllDoctors(): Observable<Doctor[]> { … }] – entspricht GET /getAllDoctors; jede Methode entspricht genau einer der elf Routen des [NestJS]-Controllers (Kapitel 3) – tatsächlich tauchen auf beiden Seiten dieselben Namen auf, was den Abgleich von Server- und Client-Code erleichtert;
  • Zeile 44: [private extract<T>(response: ServerResponse<T>): T {] – statt die Prüfung „wenn status !== 0, liegt ein Fehler vor“ in jeder der öffentlichen Methoden zu wiederholen, zentralisieren wir sie hier ein einziges Mal;
  • Zeile 46: [throw new Error(…)] – eine in `map()` geworfene JavaScript-Exception wird von RxJS automatisch in den Zweig `error` des Abonnements (.subscribe({ next, error })) umgeleitet. Dieser Mechanismus erlaubt es der Wurzelkomponente, eine Fehlermeldung anzuzeigen, ohne jemals die Einzelheiten des Umschlags [ServerResponse]<T> kennen zu müssen.

6.6.3. src/app/core/services/auth.service.ts

Der Service, der die Anmeldung des Benutzers verwaltet: Er ruft POST /login auf, speichert das erhaltene JWT-Token (und die zugehörige Identität/Rolle) als Signals und sorgt mithilfe von localStorage dafür, dass es ein Neuladen der Seite übersteht. Dies ist neben [AppointmentService] die einzige weitere Stelle der Anwendung, die per HTTP mit dem Server kommuniziert – eine beabsichtigte Ausnahme von der Regel des „einzigen HTTP-Services“, die auf der Client-Seite die Trennung widerspiegelt, die serverseitig bereits zwischen RdvMedecinsController und AuthController vorgenommen wurde.

  import { Injectable, computed, inject, signal } from '@angular/core';
  import { HttpClient } from '@angular/common/http';
  import { Observable, map, tap } from 'rxjs';
  import { SettingsService } from './settings.service';
  import { LoginResult, ServerResponse, Role } from '../models/appointment.models';

  interface StoredSession {
    accessToken: string;
    login: string;
   name: string;
   role: Role;
 }

 const STORAGE_KEY = 'rdvmedecins.session';

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

   private readonly session = signal<StoredSession | null>(readStoredSession());
   readonly isLoggedIn = computed(() => this.session() !== null);
   readonly login = computed(() => this.session()?.login ?? null);
   readonly name = computed(() => this.session()?.name ?? null);
   readonly role = computed(() => this.session()?.role ?? null);
   readonly isAdmin = computed(() => this.role() === 'ADMIN');

   readonly accessToken = computed(() => this.session()?.accessToken ?? null);

   logIn(login: string, password: string): Observable<LoginResult> {
     return this.http
       .post<ServerResponse<LoginResult>>(`${this.settings.apiBaseUrl()}/login`, { login, password })
       .pipe(
         map((response) => {
           if (response.status !== 0 || response.data === null) {
             throw new Error('Login failed');
           }
           return response.data;
         }),
         tap((result) => this.saveSession(result)),
       );
   }

   logOut(): void {
     this.session.set(null);
     localStorage.removeItem(STORAGE_KEY);
   }

   private saveSession(result: LoginResult): void {
     const newSession: StoredSession = result;
     this.session.set(newSession);
     localStorage.setItem(STORAGE_KEY, JSON.stringify(newSession));
   }
 }

 function readStoredSession(): StoredSession | null {
   try {
     const raw = localStorage.getItem(STORAGE_KEY);
     return raw ? (JSON.parse(raw) as StoredSession) : null;
   } catch {
     return null;
   }
 }

Kommentieren wir diesen Code:

  • Zeilen 7–12: [interface StoredSession { … }] – das Format dessen, was in localStorage geschrieben bzw. daraus gelesen wird – ein einfaches JSON-Objekt, absichtlich von [LoginResult] unterschieden (auch wenn es alle dessen Felder enthält);
  • Zeile 21: [private readonly session = signal<StoredSession | null>(readStoredSession());] – aus localStorage initialisiert: Lädt der Benutzer die Seite nach der Anmeldung neu, bleibt er angemeldet (bis das Token serverseitig abläuft oder er sich explizit abmeldet);
  • Zeile 22: [readonly isLoggedIn = computed(() => this.session() !== null);] – `computed()` erzeugt ein abgeleitetes Signal: Sein Wert wird automatisch neu berechnet, sobald sich die Sitzung ändert, und jede Komponente, die es liest (auth.isLoggedIn() in [app.html]), wird ihrerseits benachrichtigt;
  • Zeilen 23–26: [login / name / role / isAdmin] – abgeleitete Signals, den Komponenten schreibgeschützt bereitgestellt (app.ts, login.component.ts, schedule.component.ts über canEdit);
  • Zeile 28: [readonly accessToken = computed(() => this.session()?.accessToken ?? null);] – das Token, das jeder geschützten HTTP-Anfrage beizufügen ist und von auth.interceptor.ts (unten) gelesen wird;
  • Zeile 30: [logIn(login: string, password: string): Observable {] – entspricht POST /login, JSON-Body { login, password };
  • Zeilen 34–39: [map((response) => { if (response.status !== 0 …) { throw …; } return response.data; })] – dasselbe Prinzip wie AppointmentService.extract(), hier inline umgeschrieben statt als Aufruf (keine zwischen den beiden Services geteilte private Methode, die absichtlich unabhängig bleiben);
  • Zeile 40: [tap((result) => this.saveSession(result)),] – `tap()` führt einen Seiteneffekt aus (hier: das Speichern der Sitzung) ohne den Wert zu ändern, der anschließend an den Abonnenten weitergegeben wird – anders als `map()`, das diesen Wert transformiert;
  • Zeilen 44–47: [logOut(): void { this.session.set(null); localStorage.removeItem(…); }] – rein lokal (kein Serveraufruf): Ein JWT-Token wird in diesem ersten Port serverseitig nicht „widerrufen“; es läuft nach JWT_EXPIRES_IN von selbst ab;
  • Zeile 56: [function readStoredSession(): StoredSession | null {] – durch einen try/catch-Block geschützt: localStorage kann nicht verfügbar sein (bei sehr restriktivem privatem Surfen) oder einen beschädigten Wert enthalten – in diesem Fall nehmen wir einfach an, dass es keine Sitzung gibt.

6.6.4. src/app/core/services/language.service.ts

Ein kleiner Service, der den Sprachwechsel der Oberfläche (Französisch/Englisch) zentralisiert. Für die eigentliche Übersetzungsarbeit stützt er sich auf [TranslateService] ([@ngx-translate/core], konfiguriert in app.config.ts weiter unten) und ergänzt, was sich bereits in [SettingsService] und [AuthService] findet: ein Signal, das dem Rest der Anwendung bereitgestellt wird, und die Speicherung der Wahl des Benutzers in localStorage.

  import { Injectable, inject } from '@angular/core';
  import { TranslateService } from '@ngx-translate/core';

  const STORAGE_KEY = 'rdvmedecins.language';

  export type Language = 'fr' | 'en';

  @Injectable({ providedIn: 'root' })
  export class LanguageService {
   private readonly translate = inject(TranslateService);

   readonly currentLanguage = this.translate.currentLang;

   constructor() {
     const initialLanguage = (localStorage.getItem(STORAGE_KEY) as Language | null) ?? (navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : null);
     if (initialLanguage && initialLanguage !== this.translate.getCurrentLang()) {
       this.applyLanguage(initialLanguage);
     }
   }

   changeLanguage(language: Language): void {
     localStorage.setItem(STORAGE_KEY, language);
     this.applyLanguage(language);
   }

   private applyLanguage(language: Language): void {
     this.translate.use(language).subscribe(() => {
       document.documentElement.lang = language;
     });
   }
 }

Zerlegen wir diesen Code:

  • Zeile 10: [private readonly translate = inject(TranslateService);] – [TranslateService] ist der zentrale Service von [@ngx-translate/core]: Er lädt ein Übersetzungswörterbuch und löst einen Schlüssel ('LOGIN.TITLE') in Text auf ('Login' oder 'Connexion', je nach aktueller Sprache);
  • Zeile 12: [readonly currentLanguage = this.translate.currentLang;] – seit Version 18 von [@ngx-translate/core] stellt [TranslateService] currentLang bereits als Signal bereit: Wir müssen hier keines neu erstellen, sondern veröffentlichen es lediglich unter diesem Namen erneut – damit der Rest des Anwendungscodes (siehe [app.html]) [TranslateService] selbst nie importieren muss, sondern nur [LanguageService];
  • Zeilen 14–19: [constructor() { const initialLanguage = …; if (…) { this.applyLanguage(initialLanguage); } }]– beim Start: Hatte der Benutzer bei einem früheren Besuch bereits eine Sprache gewählt, wird sie wiederhergestellt; andernfalls wird Französisch verwendet, wenn der Browser auf Französisch eingestellt ist, sonst bleibt die in app.config.ts festgelegte Standardsprache (Englisch) erhalten;
  • Zeilen 21–24: [changeLanguage(language: Language): void { localStorage.setItem(…); this.applyLanguage(language); }] – wird von den beiden Schaltflächen FR/EN in der Navigationsleiste aufgerufen (siehe [app.html]);
  • Zeilen 26–30: [private applyLanguage(language: Language): void { this.translate.use(language).subscribe(() => { document.documentElement.lang = language; }); }] – translate.use(language) lädt (falls nötig) die entsprechende Datei public/i18n/<language>.json und schaltet dann die aktuelle Sprache um; es handelt sich um ein Observable, das ein Signal sendet, sobald das Laden abgeschlossen ist – wir nutzen diese Gelegenheit, um das Attribut <html lang="..."> der Seite zu aktualisieren (nützlich für die Barrierefreiheit), worum sich [Angular] nicht selbst kümmert, da index.html eine statische Seite ist, die geladen wird, noch bevor die Anwendung startet.

Entspricht der Schaltfläche „FR / EN“ im ursprünglichen AngularJS-1.x-Client, der sich damals auf die Bibliothek angular-translate stützte – den Vorläufer des hier verwendeten ngx-translate im Ökosystem von AngularJS 1.x.

6.7. Übersetzungswörterbücher (public/i18n/)

TranslateHttpLoader ([@ngx-translate/http-loader], konfiguriert in app.config.ts weiter unten) lädt eine dieser beiden Dateien über eine Anfrage HTTP GET [/i18n/]<language>.json, sobald sich die Sprache ändert (oder beim ersten Mal verwendet wird). [TranslateService] macht dieses JSON dann zu einem flachen Wörterbuch "LOGIN.TITLE", "SCHEDULE.FREE" …, das von der Pipe | translate abgefragt wird, die in allen Templates im Verzeichnis features/ verwendet wird (siehe weiter unten in diesem Kapitel).

Image

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / Angular",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "SUBMITTING": "Connexion...",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
    "DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
    "DEMO_ACCOUNTS_OR": "ou",
    "DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Médecin",
    "CHOOSE_DOCTOR": "-- choisir un médecin --",
    "DAY_LABEL": "Jour",
    "VIEW_SCHEDULE": "Voir l'agenda"
  },
  "SCHEDULE": {
    "TITLE_PREFIX": "Agenda du",
    "COLUMN_SLOT": "Créneau",
    "COLUMN_STATUS": "Statut",
    "FREE": "Libre",
    "BOOK": "Réserver",
    "CANCEL_APPOINTMENT": "Annuler",
    "EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda »."
  },
  "BOOKING_DIALOG": {
    "TITLE": "Réserver ce créneau",
    "CLOSE_ARIA": "Fermer",
    "SLOT_FROM": "Créneau de",
    "SLOT_TO": "à",
    "PATIENT_LABEL": "Patient",
    "CHOOSE_PATIENT": "-- choisir un patient --",
    "CANCEL": "Annuler",
    "CONFIRM": "Confirmer"
  }
}

Kommentieren wir diesen Code:

  • Zeile 1: [{] – ein verschachteltes JSON-Objekt, ein Abschnitt pro Komponente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); [TranslateService] macht daraus ein flaches Wörterbuch, in dem jeder vollständige Schlüssel ("LOGIN.TITLE") durch Verbinden des Pfads mit Punkten gebildet wird;
  • Zeilen 14–17: [“DEMO_ACCOUNTS_PREFIX” / “DEMO_ACCOUNTS_ADMIN” / “DEMO_ACCOUNTS_OR” / “DEMO_ACCOUNTS_USER”] – ein Satz, der auf vier Schlüssel statt auf einen einzigen verteilt ist: Der vollständige Text des ursprünglichen Dokuments („Demo accounts: admin / admin (role ADMIN…) or user / user (role USER…)“) enthält außerdem Elemente <code>admin</code>, die nicht übersetzt werden dürfen (es sind Zugangsdaten, in beiden Sprachen identisch) – sie müssen daher zwischen die übersetzten Fragmente eingefügt werden (siehe login.component.html unten);
  • Zeile 32: [“EMPTY_STATE”: “Choisissez un médecin et un jour, puis cliquez sur « Voir l’agenda ».”] – anders als die meisten anderen Schlüssel (die einfache Beschriftungen sind) ist dies ein vollständiger Satz: Nichts spricht dagegen, dass ein Übersetzungsschlüssel Satzzeichen oder mehrere Wörter enthält, solange er einem einzelnen Textblock im Template entspricht.

6.7.2. public/i18n/en.json

  {
    "APP": {
      "TITLE": "RdvMedecins - NestJS / Angular port",
      "SERVER_URL_LABEL": "Server URL",
      "LOGOUT": "Log out"
    },
    "LOGIN": {
      "TITLE": "Login",
      "LOGIN_LABEL": "Login",
     "PASSWORD_LABEL": "Password",
     "SUBMIT": "Log in",
     "SUBMITTING": "Signing in...",
     "ERROR": "Incorrect login or password.",
     "DEMO_ACCOUNTS_PREFIX": "Demo accounts:",
     "DEMO_ACCOUNTS_ADMIN": "(ADMIN role, full access)",
     "DEMO_ACCOUNTS_OR": "or",
     "DEMO_ACCOUNTS_USER": "(USER role, read-only)"
   },
   "DOCTOR_DAY_PICKER": {
     "DOCTOR_LABEL": "Doctor",
     "CHOOSE_DOCTOR": "-- choose a doctor --",
     "DAY_LABEL": "Day",
     "VIEW_SCHEDULE": "View schedule"
   },
   "SCHEDULE": {
     "TITLE_PREFIX": "Schedule for",
     "COLUMN_SLOT": "Slot",
     "COLUMN_STATUS": "Status",
     "FREE": "Free",
     "BOOK": "Book",
     "CANCEL_APPOINTMENT": "Cancel",
     "EMPTY_STATE": "Choose a doctor and a day, then click "View schedule"."
   },
   "BOOKING_DIALOG": {
     "TITLE": "Book this slot",
     "CLOSE_ARIA": "Close",
     "SLOT_FROM": "Slot from",
     "SLOT_TO": "to",
     "PATIENT_LABEL": "Patient",
     "CHOOSE_PATIENT": "-- choose a patient --",
     "CANCEL": "Cancel",
     "CONFIRM": "Confirm"
   }
 }

Zerlegen wir diesen Code:

  • Zeile 3: [“TITLE”: “RdvMedecins - NestJS / Angular port”,] – nur der Untertitel ändert sich: „[RdvMedecins]“ bleibt in beiden Sprachen gleich; es ist der Eigenname der Anwendung;
  • Zeile 11: [“SUBMIT”: “Log in”,] – angepasste statt wörtliche Übersetzung („Connect“ wäre eine direkte Übersetzung aus dem Französischen gewesen): Die englische Standardterminologie der Authentifizierung unterscheidet zwischen „log in“ (Verb, die Handlung des Anmeldens) und „login“ (Substantiv, der eingegebene Benutzername – siehe Zeile 9, die in beiden Sprachen „[Login]“ bleibt, da es auch der Name des vom Server erwarteten Feldes ist; siehe [LoginDto] in Kapitel 3).

Beide Dateien müssen strukturell identisch bleiben (dieselben Schlüssel in beiden): So ist sichergestellt, dass ein Schlüssel in beiden Sprachen existiert. Ein Schlüssel, der in einer der beiden Dateien fehlt, würde unverändert (mit seinem rohen Namen) statt mit seiner Übersetzung angezeigt, bis er ergänzt wird.

Was nicht übersetzt wird: Die vom Server zurückgegebenen Fehlermeldungen (siehe Kapitel 3, Umschlag [ServerResponse]<T>) bleiben unabhängig von der auf Client-Seite gewählten Sprache auf Englisch – diese Meldungen zu übersetzen, würde eine serverseitige Internationalisierung erfordern, die über den Rahmen dieses Schritts hinausgeht (siehe Kapitel 6, Fazit). Die Namen von Ärzten und Patienten stammen dagegen direkt aus der Datenbank und werden selbstverständlich in keinem der beiden Fälle übersetzt.

6.8. Die Schicht core/interceptors

Image

6.8.1. src/app/core/interceptors/auth.interceptor.ts

Ein HTTP-Interceptor wird zwischen [HttpClient] und das Netzwerk geschaltet: Er fängt jede ausgehende Anfrage (und ihre Antwort) ab und kann sie verändern. Dies ist das moderne Äquivalent der $http-Interceptors von AngularJS 1.x, die im ursprünglichen Dokument (Kapitel „Beispiel 6“) bereits besprochen wurden. Die Form hat sich geändert (eine einfache Funktion statt eines Objekts mit den Methoden request/response), aber die Idee bleibt dieselbe.

  import { inject } from '@angular/core';
  import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
  import { catchError, throwError } from 'rxjs';
  import { AuthService } from '../services/auth.service';

  export const authInterceptor: HttpInterceptorFn = (request, next) => {
    const auth = inject(AuthService);
    const token = auth.accessToken();

   const requestWithToken = token
     ? request.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
     : request;

   return next(requestWithToken).pipe(
     catchError((error: unknown) => {
       if (error instanceof HttpErrorResponse && error.status === 401) {
         auth.logOut();
       }
       return throwError(() => error);
     }),
   );
 };

Kommentieren wir diesen Code:

  • Zeile 6: [export const authInterceptor: HttpInterceptorFn = (request, next) => {] – Seit einigen Versionen bevorzugt [Angular] funktionale Interceptors ([HttpInterceptorFn]) – eine einfache Funktion – gegenüber den klassenbasierten Interceptors früherer Versionen von [Angular]: kürzer zu schreiben, einfacher zu registrieren (siehe app.config.ts, withInterceptors([...]));
  • Zeilen 10–12: [request.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : request;] – eine Anfrage von [HttpClient] ist ein unveränderliches Objekt – ihre Header lassen sich nicht direkt ändern; man muss eine veränderte Kopie erstellen. Diese Kopie (requestWithToken) muss an die Kette weitergereicht werden, niemals die ursprüngliche, unveränderte Anfrage;
  • Zeilen 15–18: [catchError((error) => { if (error instanceof HttpErrorResponse && error.status === 401) { auth.logOut(); } … })] – ein Fehler 401 während einer Sitzung bedeutet, dass das Token nicht mehr gültig ist (abgelaufen oder der Server wurde neu gestartet): Der Client wird sauber abgemeldet, statt in einem inkonsistenten Zustand belassen zu werden (scheinbar angemeldet, aber ohne dass eine Anfrage gelingt);
  • Zeile 19: [return throwError(() => error);] – der Fehler wird nach dieser Behandlung unverändert erneut geworfen: Der Interceptor darf den Fehler nicht vor dem aufrufenden Code verbergen ([ScheduleComponent] über [App], zum Beispiel), sondern nur nebenbei einen bestimmten Fall behandeln.

Wir könnten Authorization: Bearer ... manuell in jede der Methoden von AppointmentService einfügen. Ein Interceptor erspart diese Wiederholung: Die Frage „Wie authentifizieren wir eine Anfrage?“ wird an einer einzigen Stelle ein für alle Mal beantwortet und gilt automatisch für jeden künftigen Service, der HttpClient verwendet. Er wird in app.config.ts (unten) registriert, über provideHttpClient(withInterceptors([authInterceptor])): Ohne diese Zeile würde die Funktion zwar existieren, aber nie aufgerufen.

6.9. Konfiguration der Anwendung

Image

6.9.1. src/app/app.config.ts

  import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
  import { provideHttpClient, withInterceptors } from '@angular/common/http';
  import { provideRouter } from '@angular/router';
  import { provideTranslateService } from '@ngx-translate/core';
  import { provideTranslateHttpLoader } from '@ngx-translate/http-loader';
  import { routes } from './app.routes';
  import { authInterceptor } from './core/interceptors/auth.interceptor';

  export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
     provideRouter(routes),
     provideHttpClient(withInterceptors([authInterceptor])),
     provideTranslateService({
       lang: 'en',
       fallbackLang: 'en',
       loader: provideTranslateHttpLoader({ prefix: '/i18n/', suffix: '.json' }),
     }),
   ],
 };

Kommentieren wir diesen Code:

  • Zeile 9: [export const appConfig: ApplicationConfig = {] – was die Wurzelkomponente ([App]) erhält, um zu funktionieren. Dies ist ein Konzept, das für „Standalone“-[Angular]-Anwendungen (ohne NgModule) spezifisch ist: Jedes provideXxx() aktiviert einen anwendungsweiten Service; es gibt im ursprünglichen AngularJS-1.x-Projekt kein direktes Äquivalent dieser Datei;
  • Zeile 12: [provideRouter(routes),] – aktiviert den Angular-Router. Unsere Anwendung hat nur eine Seite: Es ist eine Komponente ([LoginComponent]), die von [App] bedingt angezeigt wird und als Anmeldebildschirm dient – nicht eine eigene Route (siehe app.routes.ts unten);
  • Zeile 13: [provideHttpClient(withInterceptors([authInterceptor])),] – aktiviert [HttpClient], das von [AppointmentService] und [AuthService] verwendet wird – das moderne Äquivalent des Services $http von AngularJS 1.x. withInterceptors ([authInterceptor]) registriert den Authentifizierungs-Interceptor: Ohne diese Zeile würde authInterceptor zwar existieren, aber nie aufgerufen;
  • Zeilen 14–18: [provideTranslateService({ lang: ‘en’, fallbackLang: ‘en’, loader: provideTranslateHttpLoader({ prefix: ‘/i18n/’, suffix: ‘.json’ }), }),] – aktiviert [@ngx-translate/core], die Bibliothek zum Umschalten der Oberfläche zwischen Französisch und Englisch. lang: 'en' legt die Startsprache fest ([LanguageService], siehe oben, ersetzt sie sofort durch die in localStorage gespeicherte Auswahl, falls vorhanden, oder durch Französisch, wenn der Browser auf Französisch eingestellt ist); fallbackLang: 'en' würde verwendet, wenn ein Übersetzungsschlüssel im Wörterbuch der aktuellen Sprache fehlte; loader: provideTranslateHttpLoader(...) legt fest, WIE die Wörterbücher geladen werden – hier über eine Anfrage HTTP GET auf statische JSON-Dateien (public/i18n/fr.json, public/i18n/en.json, siehe oben), wobei Präfix und Suffix die vollständige URL bilden (Präfix + Sprache + Suffix, zum Beispiel /i18n/en.json).

6.9.2. src/app/app.routes.ts

1
2
3
import { Routes } from '@angular/router';

export const routes: Routes = [];

Kommentieren wir diesen Code:

  • Zeile 3: [export const routes: Routes = [];] – die Routing-Tabelle bleibt leer: Die Anwendung passt auf eine einzige Seite (die Wurzelkomponente [App] zeigt je nach AuthService.isLoggedIn() entweder den Anmeldebildschirm oder die Auswahl von Arzt/Tag + den Terminkalender + das Buchungsfenster an). Wir hätten statt einer bedingten Anzeige eine Route /login anlegen können, aber für eine Single-Page-Anwendung hätte dieser Umweg keinen Zweck erfüllt.

6.10. Die Schicht features: die vier Komponenten

Image

6.10.1. src/app/features/login/login.component.ts

Der Anmeldebildschirm: das Äquivalent der View [login.html] des ursprünglichen AngularJS-1.x-Clients (die erste Ansicht, die die Anwendung anzeigt).

  import { Component, DestroyRef, inject, signal } from '@angular/core';
  import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
  import { TranslatePipe } from '@ngx-translate/core';
  import { AuthService } from '../../core/services/auth.service';

  @Component({
    selector: 'app-login',
    imports: [TranslatePipe],
    templateUrl: './login.component.html',
   styleUrl: './login.component.css',
 })
 export class LoginComponent {
   private readonly auth = inject(AuthService);
   private readonly destroyRef = inject(DestroyRef);

   protected readonly login = signal('');
   protected readonly password = signal('');

   protected readonly inProgress = signal(false);
   protected readonly error = signal<string | null>(null);

   onLoginChange(event: Event): void {
     this.login.set((event.target as HTMLInputElement).value);
   }

   onPasswordChange(event: Event): void {
     this.password.set((event.target as HTMLInputElement).value);
   }

   onSubmit(): void {
     if (this.login().trim() === '' || this.password() === '') {
       return;
     }
     this.error.set(null);
     this.inProgress.set(true);
     this.auth
       .logIn(this.login(), this.password())
       .pipe(takeUntilDestroyed(this.destroyRef))
       .subscribe({
         next: () => this.inProgress.set(false),
         error: () => {
           this.inProgress.set(false);
           this.error.set('LOGIN.ERROR');
         },
       });
   }
 }

Kommentieren wir diesen Code:

  • Zeile 8: [imports: [TranslatePipe],] – eine Standalone-Komponente deklariert die Pipes, die sie in ihrem Template verwendet; [TranslatePipe] ([@ngx-translate/core]) macht | translate in login.component.html (unten) verfügbar;
  • Zeilen 16–17: [protected readonly login = signal(’‘); protected readonly password = signal(’’);] – Zustand, der rein lokal zum Formular gehört (was der Benutzer gerade eintippt);
  • Zeile 19: [protected readonly inProgress = signal(false);] – true während des Netzwerkaufrufs: deaktiviert die Schaltfläche, um einen Doppelklick zu verhindern;
  • Zeile 20: [protected readonly error = signal<string | null>(null);] – speichert einen Übersetzungsschlüssel, keinen bereits übersetzten Text: Die Pipe | translate im Template löst ihn zum Zeitpunkt der Anzeige auf;
  • Zeile 30: [onSubmit(): void {] – wird von der Schaltfläche „Log in“ ausgelöst (siehe das Template unten);
  • Zeile 40: [next: () => this.inProgress.set(false),] – hier ist keine weitere Verarbeitung nötig: [AuthService] hat die Sitzung bereits gespeichert (Signal + localStorage) – es ist [App], das auth.isLoggedIn() liest und darauf reagiert, indem es <app-login> nicht mehr anzeigt;
  • Zeilen 41–44: [error: () => { …this.error.set(‘LOGIN.ERROR’); }] – eine ungültige Kombination aus Benutzername und Passwort lässt logIn() mit einem HTTP-Fehler 401 fehlschlagen (siehe Kapitel 3, [LocalStrategy]): Dem Benutzer wird einfach 'LOGIN.ERROR' angezeigt („Incorrect login or password.“ / „Login ou mot de passe incorrect.“, je nach Sprache), ohne zwischen einem nicht existierenden Benutzernamen und einem falschen Passwort zu unterscheiden (vorsichtshalber, wie es jede reale Anwendung tun würde). Das Speichern eines Schlüssels statt eines Klartexts hat einen praktischen Vorteil: Wechselt der Benutzer die Sprache, während diese Meldung angezeigt wird, übersetzt sie sich automatisch, ohne dass hier zusätzlicher Code nötig wäre.

6.10.2. src/app/features/login/login.component.html

  <div class="row justify-content-center">
    <div class="col-sm-8 col-md-6 col-lg-4">
      <div class="card p-4">
        <h5 class="card-title mb-3">{{ 'LOGIN.TITLE' | translate }}</h5>

        @if (error(); as errorMessage) {
          <div class="alert alert-danger py-2" role="alert">{{ errorMessage | translate }}</div>
        }

       <div class="mb-3">
         <label class="form-label" for="input-login">{{ 'LOGIN.LOGIN_LABEL' | translate }}</label>
         <input id="input-login" type="text" class="form-control" autocomplete="username"
                [value]="login()" (input)="onLoginChange($event)" (keyup.enter)="onSubmit()">
       </div>

       <div class="mb-3">
         <label class="form-label" for="input-password">{{ 'LOGIN.PASSWORD_LABEL' | translate }}</label>
         <input id="input-password" type="password" class="form-control" autocomplete="current-password"
                [value]="password()" (input)="onPasswordChange($event)" (keyup.enter)="onSubmit()">
       </div>

       <button type="button" class="btn btn-primary w-100" [disabled]="inProgress()" (click)="onSubmit()">
         @if (inProgress()) { {{ 'LOGIN.SUBMITTING' | translate }} } @else { {{ 'LOGIN.SUBMIT' | translate }} }
       </button>

       <p class="text-muted small mt-3 mb-0">
         {{ 'LOGIN.DEMO_ACCOUNTS_PREFIX' | translate }} <code>admin</code> / <code>admin</code> {{ 'LOGIN.DEMO_ACCOUNTS_ADMIN' | translate }}
         {{ 'LOGIN.DEMO_ACCOUNTS_OR' | translate }} <code>user</code> / <code>user</code> {{ 'LOGIN.DEMO_ACCOUNTS_USER' | translate }}.
       </p>
     </div>
   </div>
 </div>

Zerlegen wir diesen Code:

  • Zeilen 1–2: [] – Bootstrap-Grid-Klassen: zentriert eine Karte mit fester Breite horizontal, unabhängig von der Bildschirmbreite;
  • Zeilen 12–13, 18–19: [(input)=“onLoginChange($event)” (keyup.enter)=“onSubmit()”] — kein FormsModule/ngModel: Die Felder werden direkt über das DOM-Ereignis (input) gelesen, und (keyup.enter) ermöglicht es, das Formular per Tastatur abzusenden, ohne Maus;
  • Zeile 22: [[disabled]=“inProgress()”] — der Button ist während des Netzwerkaufrufs deaktiviert (siehe LoginComponent.inProgress), um einen Doppelklick zu verhindern, solange der erste Versuch noch läuft;
  • Zeilen 27–28: [{{ ‘LOGIN.DEMO_ACCOUNTS_PREFIX’ | translate }} admin / admin {{ ‘LOGIN.DEMO_ACCOUNTS_ADMIN’ | translate }} …] — der Text zu den Demokonten wechselt zwischen übersetztem Text und nicht übersetzten Bezeichnern (<code>admin</code>, <code>user</code>): Um diese Mischung zu ermöglichen, wurde der Satz in den JSON-Wörterbüchern in vier separate Schlüssel aufgeteilt (siehe oben, public/i18n/fr.json), statt in einen einzigen Schlüssel mit dem gesamten Satz.

6.10.3. src/app/features/doctor-day-picker/doctor-day-picker.component.ts

Die Komponente, mit der Sie einen Arzt und ein Datum auswählen und anschließend dessen Terminkalender anzeigen können. Konzeptionell entspricht sie den Beispielen 7 bis 10 des ursprünglichen AngularJS-1.x-Clients.

  import { Component, input, output, signal } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { Doctor } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-doctor-day-picker',
    imports: [TranslatePipe],
    templateUrl: './doctor-day-picker.component.html',
    styleUrl: './doctor-day-picker.component.css',
 })
 export class DoctorDayPickerComponent {
   readonly doctors = input.required<Doctor[]>();
   readonly search = output<{ doctorId: number; day: string }>();

   readonly selectedDoctorId = signal<number | null>(null);
   readonly selectedDay = signal<string>(new Date().toISOString().slice(0, 10));

   onDoctorChange(event: Event): void {
     const value = (event.target as HTMLSelectElement).value;
     this.selectedDoctorId.set(value === '' ? null : Number(value));
   }

   onDayChange(event: Event): void {
     this.selectedDay.set((event.target as HTMLInputElement).value);
   }

   onSearchClick(): void {
     const doctorId = this.selectedDoctorId();
     if (doctorId === null) {
       return;
     }
     this.search.emit({ doctorId, day: this.selectedDay() });
   }
 }

Sehen wir uns diesen Code genauer an:

  • Zeile 7: [imports: [TranslatePipe],] — macht | translate in doctor-day-picker.component.html (siehe unten) verfügbar;
  • Zeile 12: [readonly doctors = input.required<Doctor[]>();] — legt fest, dass diese Komponente die Liste der Ärzte von ihrer übergeordneten Komponente ([App]) erhalten muss — [Angular] meldet einen Fehler, wenn diese Komponente verwendet wird, ohne dass dieser Eingabewert übergeben wird. input() (signalbasiert) ersetzt das veraltete Schlüsselwort @Input(): [doctors]() wird als Funktion behandelt, wodurch [Angular] genau weiß, wann die Komponente neu gezeichnet werden muss;
  • Zeile 13: [readonly search = output<{ doctorId: number; day: string }>();] — deklariert das Ereignis, das diese Komponente an ihre übergeordnete Komponente weitergibt – das Äquivalent zu einem benutzerdefinierten Ereignis ($emit/$broadcast) in AngularJS 1.x;
  • Zeilen 15–16: [selectedDoctorId / selectedDay] — ein Zustand, der nur dieser Komponente gehört (was in den Menüs ausgewählt ist, solange der Benutzer den Button nicht angeklickt hat); selectedDay wird mit dem heutigen Datum initialisiert;
  • Zeilen 27–33: [onSearchClick(): void { … this.search.emit({ doctorId, day: … }); }] — ruft HTTP nicht selbst auf: Sie reicht lediglich die Absicht des Benutzers an die übergeordnete Komponente weiter, die entscheidet, ob AppointmentService aufgerufen wird.

6.10.4. src/app/features/doctor-day-picker/doctor-day-picker.component.html

  <div class="card p-3 mb-3">
    <div class="row g-2 align-items-end">
      <div class="col-sm-5">
        <label class="form-label" for="select-doctor">{{ 'DOCTOR_DAY_PICKER.DOCTOR_LABEL' | translate }}</label>
        <select id="select-doctor" class="form-select" (change)="onDoctorChange($event)">
          <option value="">{{ 'DOCTOR_DAY_PICKER.CHOOSE_DOCTOR' | translate }}</option>
          @for (doctor of doctors(); track doctor.id) {
            <option [value]="doctor.id">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</option>
          }
       </select>
     </div>
     <div class="col-sm-4">
       <label class="form-label" for="input-day">{{ 'DOCTOR_DAY_PICKER.DAY_LABEL' | translate }}</label>
       <input id="input-day" type="date" class="form-control" [value]="selectedDay()" (change)="onDayChange($event)">
     </div>
     <div class="col-sm-3">
       <button type="button" class="btn btn-primary w-100" [disabled]="selectedDoctorId() === null" (click)="onSearchClick()">
         {{ 'DOCTOR_DAY_PICKER.VIEW_SCHEDULE' | translate }}
       </button>
     </div>
   </div>
 </div>

Sehen wir uns diesen Code genauer an:

  • Zeile 7: [@for (doctor of doctors(); track doctor.id) {] — [@for] ist die neue Syntax zur Ablaufsteuerung von [Angular] (ersetzt *ngFor): Sie wiederholt ein <option> für jeden von der übergeordneten Komponente empfangenen Arzt. track doctor.[id] teilt [Angular] mit, wie ein bereits angezeigter Arzt wiederzuerkennen ist, falls er neu gezeichnet wird;
  • Zeile 17: [[disabled]=“selectedDoctorId() === null”] — der Button bleibt deaktiviert, solange kein Arzt ausgewählt ist, um eine unvollständige Suche zu verhindern;
  • Zeilen 4, 6, 13, 18: [{{ ‘…’ | translate }}] — die vier statischen Beschriftungen dieser Komponente („Doctor“, „-- choose a doctor --“, „Day“, „View schedule“), übersetzt mit der Pipe | translate (siehe [LanguageService] oben). Der Name jedes Arztes (Zeile 8) stammt dagegen direkt aus den Serverdaten und wird nie übersetzt.

6.10.5. src/app/features/schedule/schedule.component.ts

Zeigt den Terminkalender eines Arztes für einen bestimmten Tag an: eine Liste seiner Zeitfenster, die jeweils entweder frei sind (Button „Book“) oder gebucht (Name des Patienten + Button „Cancel“). Entspricht den Beispielen 8 und 9 des ursprünglichen AngularJS-1.x-Clients.

  import { Component, input, output } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-schedule',
    imports: [TranslatePipe],
    templateUrl: './schedule.component.html',
    styleUrl: './schedule.component.css',
 })
 export class ScheduleComponent {
   readonly schedule = input<DoctorDaySchedule | null>(null);

   readonly canEdit = input<boolean>(true);

   readonly book = output<SlotJson>();
   readonly cancel = output<AppointmentJson>();

   formatTime(h: number, m: number): string {
     return `${h}:${m.toString().padStart(2, '0')}`;
   }

   onSlotClick(scheduleSlot: ScheduleSlot): void {
     if (!this.canEdit()) {
       return;
     }
     if (scheduleSlot.appointment === null) {
       this.book.emit(scheduleSlot.slot);
     } else {
       this.cancel.emit(scheduleSlot.appointment);
     }
   }
 }

Kommentieren wir diesen Code:

  • Zeile 12: [readonly schedule = input<DoctorDaySchedule | null>(null);] — `input()` ohne `.required` erlaubt einen Standardwert (hier `null`): Er ist `null`, bis eine Suche durchgeführt wird;
  • Zeile 14: [readonly canEdit = input<boolean>(true);] — eine mit der Authentifizierung eingeführte Neuerung: standardmäßig true (Rolle ADMIN); [App] übergibt ihr auth.isAdmin() (siehe [app.html]). Ist der Wert false (Rolle USER), verschwinden die Buttons „Book“/„Cancel“ aus dem Template (siehe unten) – der Kalender bleibt einsehbar, jedoch nur lesend;
  • Zeilen 23–26: [onSlotClick(scheduleSlot: ScheduleSlot): void { if (!this.canEdit()) { return; } … }] — dieser Anwendungs-Guard ist redundant zum im Template ausgeblendeten Button (eine Rolle USER sieht diesen Button nie): Er schützt dennoch vor einem programmatischen Aufruf dieser Methode und dokumentiert die Absicht an derselben Stelle wie die übrige Logik. Zur Erinnerung: Die einzige echte Absicherung bleibt in jedem Fall der Server ([RolesGuard], Kapitel 3) – ein manuell veränderter [Angular]-Client könnte diese Einschränkung nicht umgehen;
  • Zeilen 27–31: [if (scheduleSlot.appointment === null) { this.book.emit(…); } else { this.cancel.emit(…); }] — ist das Zeitfenster frei, wird der Benutzer zur Buchung aufgefordert; ist es bereits gebucht, wird er zur Stornierung des bestehenden Termins aufgefordert. Diese Komponente führt selbst keine HTTP-Aufrufe aus: Sie zeigt die empfangenen Daten an und benachrichtigt ihre übergeordnete Komponente über die Absichten des Benutzers.

6.10.6. src/app/features/schedule/schedule.component.html

  @if (schedule(); as currentSchedule) {
    <div class="card p-3">
      <h5>{{ 'SCHEDULE.TITLE_PREFIX' | translate }} {{ currentSchedule.day }} - {{ currentSchedule.doctor.title }} {{ currentSchedule.doctor.firstName }} {{ currentSchedule.doctor.lastName }}</h5>

      <table class="table table-hover align-middle">
        <thead>
          <tr><th>{{ 'SCHEDULE.COLUMN_SLOT' | translate }}</th><th>{{ 'SCHEDULE.COLUMN_STATUS' | translate }}</th><th></th></tr>
        </thead>
        <tbody>
         @for (scheduleSlot of currentSchedule.slots; track scheduleSlot.slot.id) {
           <tr [class.free-slot]="scheduleSlot.appointment === null">
             <td>{{ formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute) }} - {{ formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute) }}</td>
             <td>
               @if (scheduleSlot.appointment === null) {
                 <span class="badge text-bg-success">{{ 'SCHEDULE.FREE' | translate }}</span>
               } @else {
                 <span class="badge text-bg-secondary">{{ scheduleSlot.appointment.client?.title }} {{ scheduleSlot.appointment.client?.firstName }} {{ scheduleSlot.appointment.client?.lastName }}</span>
               }
             </td>
             <td>
               @if (canEdit()) {
                 <button type="button" class="btn btn-sm" [class.btn-outline-success]="scheduleSlot.appointment === null"
                         [class.btn-outline-danger]="scheduleSlot.appointment !== null" (click)="onSlotClick(scheduleSlot)">
                   {{ scheduleSlot.appointment === null ? ('SCHEDULE.BOOK' | translate) : ('SCHEDULE.CANCEL_APPOINTMENT' | translate) }}
                 </button>
               }
             </td>
           </tr>
         }
       </tbody>
     </table>
   </div>
 } @else {
   <p class="text-muted">{{ 'SCHEDULE.EMPTY_STATE' | translate }}</p>
 }

Kommentieren wir diesen Code:

  • Zeile 1: [@if (schedule(); as currentSchedule) {] — @if und @for sind die neue Syntax zur Ablaufsteuerung in [Angular]: Sie ersetzen *ngIf bzw. *ngFor und sind Teil der Template-Sprache selbst (kein Modulimport erforderlich). as currentSchedule erfasst den Wert ungleich null in einer Template-Variablen, sodass `schedule()!` im weiteren Verlauf nicht überall wiederholt werden muss;
  • Zeilen 14–18: [@if (scheduleSlot.appointment === null) { ... } @else { ... }] — grünes Bootstrap-Badge („Free“/„Libre“) oder graues (Name des Patienten), je nach Status des Zeitfensters;
  • Zeile 21: [@if (canEdit()) {] — eine mit der Authentifizierung eingeführte Neuerung: Der Button „Book“/„Cancel“ existiert für die Rolle USER im DOM gar nicht (canEdit() ist dann false) – er ist nicht nur ausgegraut oder deaktiviert, sondern vollständig abwesend;
  • Zeile 24: [{{ scheduleSlot.appointment === null ? (‘SCHEDULE.BOOK’ | translate) : (‘SCHEDULE.CANCEL_APPOINTMENT’ | translate) }}] — eine Pipe kann in jedem Template-Ausdruck verwendet werden, auch in einem ternären Operator, sofern jeder Zweig korrekt in Klammern gesetzt ist.

6.10.7. src/app/features/booking-dialog/booking-dialog.component.ts

Das (modale) Fenster, in dem Sie einen Patienten auswählen, um ein freies Zeitfenster zu buchen. Entspricht Beispiel 9 des ursprünglichen AngularJS-1.x-Clients.

  import { Component, input, output, signal } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { Client, SlotJson } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-booking-dialog',
    imports: [TranslatePipe],
    templateUrl: './booking-dialog.component.html',
    styleUrl: './booking-dialog.component.css',
 })
 export class BookingDialogComponent {
   readonly open = input.required<boolean>();
   readonly slot = input<SlotJson | null>(null);
   readonly clients = input.required<Client[]>();

   readonly confirm = output<{ clientId: number }>();
   readonly close = output<void>();

   readonly selectedClientId = signal<number | null>(null);

   onClientChange(event: Event): void {
     const value = (event.target as HTMLSelectElement).value;
     this.selectedClientId.set(value === '' ? null : Number(value));
   }

   onConfirmClick(): void {
     const clientId = this.selectedClientId();
     if (clientId === null) {
       return;
     }
     this.confirm.emit({ clientId });
     this.selectedClientId.set(null);
   }

   onCloseClick(): void {
     this.selectedClientId.set(null);
     this.close.emit();
   }
 }

Kommentieren wir diesen Code:

  • Zeile 12: [readonly open = input.required<boolean>();] — die Komponente ist im Template der übergeordneten Komponente ([App]) immer vorhanden: Dieser Eingabewert steuert über [@if] (siehe Template unten), ob sie angezeigt wird oder nicht;
  • Zeilen 26–33: [onConfirmClick(): void { … this.confirm.emit({ clientId }); this.selectedClientId.set(null); }] — übergibt die ID des ausgewählten Patienten an [App], das anschließend AppointmentService.addAppointment(...) aufruft; selectedClientId wird zurückgesetzt, damit es beim nächsten Öffnen des Fensters leer ist;
  • Zeilen 35–38: [onCloseClick(): void { … this.close.emit(); }] — bricht der Benutzer ab, schließt die übergeordnete Komponente das Fenster einfach, ohne einen Aufruf an den Server zu senden.

6.10.8. src/app/features/booking-dialog/booking-dialog.component.html

Diese Komponente verwendet nun die echten Bootstrap-Klassen für ein Modal (.modal, .modal-dialog, .modal-content, .modal-backdrop …), doch ihre Sichtbarkeit wird weiterhin von [Angular] ([@if] (open())) gesteuert und nicht vom JavaScript von Bootstrap (bootstrap.bundle.js, new bootstrap.Modal(...)).

  @if (open()) {
    <div class="modal-backdrop fade show"></div>

    <div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true">
      <div class="modal-dialog modal-dialog-centered">
        <div class="modal-content">
          <div class="modal-header">
            <h5 class="modal-title">{{ 'BOOKING_DIALOG.TITLE' | translate }}</h5>
            <button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate" (click)="onCloseClick()"></button>
         </div>

         <div class="modal-body">
           @if (slot(); as currentSlot) {
             <p>{{ 'BOOKING_DIALOG.SLOT_FROM' | translate }} {{ currentSlot.startHour }}:{{ currentSlot.startMinute.toString().padStart(2, '0') }}
                {{ 'BOOKING_DIALOG.SLOT_TO' | translate }} {{ currentSlot.endHour }}:{{ currentSlot.endMinute.toString().padStart(2, '0') }}</p>
           }
           <label class="form-label" for="select-client">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}</label>
           <select id="select-client" class="form-select" (change)="onClientChange($event)">
             <option value="">{{ 'BOOKING_DIALOG.CHOOSE_PATIENT' | translate }}</option>
             @for (client of clients(); track client.id) {
               <option [value]="client.id">{{ client.title }} {{ client.firstName }} {{ client.lastName }}</option>
             }
           </select>
         </div>

         <div class="modal-footer">
           <button type="button" class="btn btn-secondary" (click)="onCloseClick()">{{ 'BOOKING_DIALOG.CANCEL' | translate }}</button>
           <button type="button" class="btn btn-primary" [disabled]="selectedClientId() === null" (click)="onConfirmClick()">
             {{ 'BOOKING_DIALOG.CONFIRM' | translate }}
           </button>
         </div>
       </div>
     </div>
   </div>
 }

Sehen wir uns diesen Code genauer an:

  • Zeile 2: [] — der halbtransparente Hintergrund, der den Rest der Seite abdunkelt – hier fest codiert, während Bootstrap ihn normalerweise beim Anzeigen des Modals selbst per JavaScript einfügt;
  • Zeile 4: [<div class=“modal fade show d-block” …>] — d-block übernimmt die Rolle, die normalerweise das JavaScript von Bootstrap erfüllt (Hinzufügen von `display:block` beim Öffnen) – hier erfüllt [@if] aus Zeile 1 diese Rolle direkt;
  • Zeilen 6–10, 12–24, 26–31: [.modal-content / .modal-header / .modal-body / .modal-footer] — die Standardstruktur eines Bootstrap-Modals (Kopfbereich mit Titel + Schließen-Button, Hauptteil, Fußbereich mit Aktionen);
  • Zeile 9: [[attr.aria-label]=“‘BOOKING_DIALOG.CLOSE_ARIA’ | translate”] — der Standard-Schließen-Button von Bootstrap (.btn-close), der mit demselben Event-Handler verbunden ist wie der Button „Cancel“ im Fußbereich des Modals (Zeile 27); sein barrierefreier Text (aria-label) wird über ein Attribut-Binding ([attr.xxx]) gesetzt statt über die einfache Interpolation {{ }}; dies ist die einzig mögliche Syntax, wenn der Wert eines HTML-Attributs kein statischer Text ist.

Warum nicht das JavaScript von Bootstrap verwenden? Weil Bootstrap und [Angular] dann jeweils unabhängig voneinander dieselbe Information verwalten würden (ist das Modal geöffnet?) – eine klassische Quelle für subtile Fehler in einer Angular-Anwendung. Indem open() (ein Signal und damit der Zustand von [Angular]) allein die Anzeige steuert, gibt es eine einzige Quelle der Wahrheit, und das visuelle Erscheinungsbild eines Bootstrap-Modals bleibt exakt erhalten. Das ursprüngliche Dokument (2014) verwendete eine Komponente der Bibliothek angular-ui-bootstrap (ein „schlüsselfertiges“ Modal für AngularJS 1.x), die bereits nach demselben Prinzip entworfen war: Zustand von [Angular] verwaltet, Erscheinungsbild von Bootstrap übernommen.

6.11. Die Wurzelkomponente [App]: Orchestrator und Authentifizierungswächter

Diese Komponente übernimmt die Rolle des „Hauptcontrollers“ der ursprünglichen AngularJS-1.x-Anwendung: Sie hält den globalen Zustand der Anwendung und reagiert auf Ereignisse der Komponenten aus features/, um [AppointmentService] zum richtigen Zeitpunkt aufzurufen. Seit der Einführung der Authentifizierung hat sie eine zweite Rolle übernommen: die eines „Türstehers“ der Präsentationsschicht, der entscheidet, ob der Anmeldebildschirm oder der Rest der Anwendung angezeigt wird.

Image

6.11.1. src/app/app.ts

  import { Component, DestroyRef, effect, inject, signal } from '@angular/core';
  import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
  import { TranslatePipe } from '@ngx-translate/core';
  import { AppointmentService } from './core/services/appointment.service';
  import { SettingsService } from './core/services/settings.service';
  import { AuthService } from './core/services/auth.service';
  import { LanguageService } from './core/services/language.service';
  // ... Modelle, Komponenten (siehe die detaillierten Imports der Datei)

 @Component({
   selector: 'app-root',
   imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],
   templateUrl: './app.html',
   styleUrl: './app.css',
 })
 export class App {
   private readonly appointmentService = inject(AppointmentService);
   private readonly destroyRef = inject(DestroyRef);
   protected readonly settings = inject(SettingsService);
   protected readonly auth = inject(AuthService);
   protected readonly language = inject(LanguageService);

   protected readonly doctors = signal<Doctor[]>([]);
   protected readonly clients = signal<Client[]>([]);
   protected readonly schedule = signal<DoctorDaySchedule | null>(null);
   protected readonly error = signal<string | null>(null);
   protected readonly slotBeingBooked = signal<SlotJson | null>(null);

   private lastDoctorId: number | null = null;
   private lastDay: string | null = null;

   constructor() {
     effect(() => {
       if (this.auth.isLoggedIn()) {
         this.loadInitialLists();
       }
     });
   }

   private loadInitialLists(): void {
     this.appointmentService.getAllDoctors().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: (doctors) => this.doctors.set(doctors),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
     this.appointmentService.getAllClients().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: (clients) => this.clients.set(clients),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
   }

   onLogout(): void {
     this.auth.logOut();
     this.doctors.set([]);
     this.clients.set([]);
     this.schedule.set(null);
     this.error.set(null);
     this.slotBeingBooked.set(null);
     this.lastDoctorId = null;
     this.lastDay = null;
   }

   onSearchSchedule(criteria: { doctorId: number; day: string }): void {
     this.error.set(null);
     this.lastDoctorId = criteria.doctorId;
     this.lastDay = criteria.day;
     this.loadSchedule();
   }

   onBookingRequest(slot: SlotJson): void {
     this.slotBeingBooked.set(slot);
   }

   onConfirmBooking(choice: { clientId: number }): void {
     const slot = this.slotBeingBooked();
     if (slot === null || this.lastDay === null) {
       return;
     }
     this.appointmentService.addAppointment(this.lastDay, choice.clientId, slot.id)
       .pipe(takeUntilDestroyed(this.destroyRef))
       .subscribe({
         next: () => { this.slotBeingBooked.set(null); this.loadSchedule(); },
         error: (err) => this.error.set(String(err.message ?? err)),
       });
   }

   onCloseBooking(): void {
     this.slotBeingBooked.set(null);
   }

   onCancelAppointment(appointment: AppointmentJson): void {
     this.appointmentService.deleteAppointment(appointment.id).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: () => this.loadSchedule(),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
   }

   private loadSchedule(): void {
     if (this.lastDoctorId === null || this.lastDay === null) {
       return;
     }
     this.appointmentService.getDoctorScheduleOfDay(this.lastDoctorId, this.lastDay)
       .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe({
        next: (schedule) => this.schedule.set(schedule),
        error: (err) => this.error.set(String(err.message ?? err)),
      });
  }
 }

Kommentieren wir diesen Code:

  • Zeile 12: [imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],] — eine Standalone-Komponente deklariert die Komponenten und Pipes, die sie in ihrem Template verwendet – [LoginComponent] wurde für die Authentifizierung zu dieser Liste hinzugefügt, [TranslatePipe] für die Übersetzung;
  • Zeile 20: [protected readonly auth = inject(AuthService);] — dem Template zugänglich gemacht (protected, nicht private) für das Rollen-/Namens-Badge und den Abmelde-Button (siehe [app.html]);
  • Zeile 21: [protected readonly language = inject(LanguageService);] — dem Template zugänglich gemacht für die beiden Buttons FR/EN in der Navigationsleiste, die im Gegensatz zum Rest der Oberfläche immer sichtbar sind (auch auf dem Anmeldebildschirm);
  • Zeile 33: [effect(() => { if (this.auth.isLoggedIn()) { this.loadInitialLists(); } });] — `effect()` führt seinen Rumpf jedes Mal erneut aus, wenn sich ein überwachtes Signal ändert – hier isLoggedIn(). Er wird außerdem einmal sofort ausgeführt: Wenn bereits eine Sitzung in localStorage gespeichert war (Neuladen der Seite), werden die Listen direkt beim Start geladen, ohne auf eine neue Anmeldung zu warten;
  • Zeile 40: [private loadInitialLists(): void {] — sobald ein Benutzer angemeldet ist (erfolgreiche Anmeldung oder wiederhergestellte Sitzung), werden die Listen der Ärzte und Clients ein für alle Mal geladen – diesmal das clientseitige Äquivalent dessen, was [ApplicationModelService] beim Start des Servers tat (Kapitel 3). Da nun alle Endpunkte des Servers durch [JwtAuthGuard] geschützt sind, wäre es ohnehin sinnlos (und würde 401-Fehler verursachen), diesen Aufruf vor der Anmeldung auszuführen;
  • Zeile 51: [onLogout(): void {] — reagiert auf den Button „Log out“: Er löscht die Sitzung und den gesamten angezeigten fachlichen Zustand (Zeilen 53–59) – ohne dies würde ein danach angemeldeter neuer Benutzer kurz den Kalender des vorherigen Benutzers sehen;
  • Zeilen 41, 45 usw.: [.pipe(takeUntilDestroyed(this.destroyRef))] — ein RxJS-Abonnement (.subscribe(...)) bleibt aktiv, bis es ausdrücklich beendet wird; das wird häufig vergessen und ist eine Quelle für Speicherlecks. Dieser Operator beendet das Abonnement automatisch, sobald die Komponente zerstört wird;
  • Zeile 69: [onBookingRequest(slot: SlotJson): void { this.slotBeingBooked.set(slot); }] — ruft den Server noch nicht auf: Sie öffnet lediglich das Buchungsfenster. Erst onConfirmBooking (Zeile 73), ausgelöst durch das Ereignis (confirm) von [BookingDialogComponent], ruft tatsächlich addAppointment auf;
  • Zeilen 81, 92: [this.loadSchedule();] — nach einer erfolgreichen Buchung oder Stornierung wird loadSchedule() erneut aufgerufen: So spiegelt der angezeigte Kalender sofort den neuen Status wider, ohne dass der Benutzer die Seite aktualisieren muss.

6.11.2. src/app/app.html

  <div class="container py-4">
    <nav class="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
      <span class="navbar-brand mb-0">{{ 'APP.TITLE' | translate }}</span>

      <div class="d-flex align-items-center gap-2">
        <div class="btn-group btn-group-sm" role="group" aria-label="FR / EN">
          <button type="button" class="btn"
                  [class.btn-light]="language.currentLanguage() === 'fr'"
                  [class.btn-outline-light]="language.currentLanguage() !== 'fr'"
                 (click)="language.changeLanguage('fr')">FR</button>
         <button type="button" class="btn"
                 [class.btn-light]="language.currentLanguage() === 'en'"
                 [class.btn-outline-light]="language.currentLanguage() !== 'en'"
                 (click)="language.changeLanguage('en')">EN</button>
       </div>

       @if (auth.isLoggedIn()) {
         <span class="badge text-bg-light text-primary">{{ auth.role() }}</span>
         <span class="text-white">{{ auth.name() }}</span>
         <button type="button" class="btn btn-sm btn-outline-light" (click)="onLogout()">
           {{ 'APP.LOGOUT' | translate }}
         </button>
       }
     </div>
   </nav>

   <div class="row g-2 align-items-center mb-4">
     <div class="col-auto"><label class="form-label mb-0" for="input-server-url">{{ 'APP.SERVER_URL_LABEL' | translate }}</label></div>
     <div class="col-sm-4">
       <input id="input-server-url" type="text" class="form-control form-control-sm"
              [value]="settings.apiBaseUrl()" (change)="settings.setApiBaseUrl($any($event.target).value)">
     </div>
   </div>

   @if (error(); as errorMessage) {
     <div class="alert alert-danger" role="alert">{{ errorMessage }}</div>
   }

   @if (!auth.isLoggedIn()) {
     <app-login />
   } @else {
     <app-doctor-day-picker [doctors]="doctors()" (search)="onSearchSchedule($event)" />

     <app-schedule
       [schedule]="schedule()"
       [canEdit]="auth.isAdmin()"
       (book)="onBookingRequest($event)"
       (cancel)="onCancelAppointment($event)"
     />

     <app-booking-dialog
       [open]="slotBeingBooked() !== null"
       [slot]="slotBeingBooked()"
       [clients]="clients()"
       (confirm)="onConfirmBooking($event)"
       (close)="onCloseBooking()"
     />
   }
 </div>

Sehen wir uns diesen Code genauer an:

  • Zeile 2: [] — Bootstrap-Klassen für eine Kopfzeile der Anwendung: ein farbiges Banner (bg-primary), heller Text (navbar-dark) und automatische horizontale Ausrichtung seines Inhalts;
  • Zeile 3: [{{ ‘APP.TITLE’ | translate }}] — erstes Beispiel für die Pipe `translate` ([@ngx-translate/core]): Statt eines fest codierten englischen Textes wird ein Schlüssel (APP.TITLE) im Wörterbuch der aktuellen Sprache aufgelöst (public/i18n/fr.json oder en.json);
  • Zeilen 6–15: [<div class=“btn-group btn-group-sm” …> … FR … EN … ] — die Sprachauswahl, die immer sichtbar ist (vor wie nach der Anmeldung, im Gegensatz zum Rollen-Badge): zwei gruppierte Bootstrap-Buttons (btn-group), von denen einer je nach aktueller Sprache (language.currentLanguage()) hervorgehoben ist (btn-light statt btn-outline-light) und deren Anklicken language.changeLanguage('fr' | 'en') aufruft;
  • Zeilen 17–23: [@if (auth.isLoggedIn()) { ... badge + name + logout button ... }] — dieser Block erscheint erst nach der Anmeldung; auth.[role]() füllt ein Bootstrap-Badge (text-bg-light badge), auth.[name]() zeigt den Namen des Benutzers an, und auch der Text des Buttons läuft über | translate (Schlüssel APP.LOGOUT);
  • Zeile 28: [{{ ‘APP.SERVER_URL_LABEL’ | translate }}] — derselbe Mechanismus wie beim Titel, angewendet auf die Beschriftung des Felds „Server URL“;
  • Zeilen 27–33: [Server URL] — bleibt vor und nach der Anmeldung angezeigt (nützlich, um auf einen anderen Server, [NestJS], zu verweisen, noch bevor man versucht, sich anzumelden);
  • Zeile 39: [@if (!auth.isLoggedIn()) { <app-login /> } @else { ... }] — der Kern der „Bereitschaftsrolle“ von [App]: Solange der Benutzer nicht angemeldet ist, wird nichts außer dem Anmeldebildschirm angezeigt – weder die Arzt-/Tag-Auswahl noch der Kalender noch das Buchungsfenster;
  • Zeile 46: [[canEdit]=“auth.isAdmin()”] — übergibt [ScheduleComponent] die Steuerung, je nachdem, ob der angemeldete Benutzer buchen/stornieren darf (Rolle ADMIN) oder nicht (Rolle USER, nur lesend);
  • Zeilen 51–57: [<app-booking-dialog … />] — immer im DOM vorhanden (wie vor der Authentifizierung): Seine Sichtbarkeit wird durch seinen Eingabewert open gesteuert.

Beachten Sie, dass die Sprachauswahl außerhalb des [@if]-Blocks (auth.isLoggedIn()) platziert ist: Sie muss bereits ab dem Anmeldebildschirm nutzbar bleiben, bevor ein JWT-Token ausgestellt wird – tatsächlich veranschaulicht der folgende Screenshot („[Login] screen“) den Wechsel zu Französisch auf genau diesem Bildschirm.

6.12. Schritt-für-Schritt-Anleitung zur Verwendung der Anwendung

Die folgenden Screenshots wurden bei der Erstellung dieses Dokuments mit einer Testkopie des Servers aufgenommen, die mit Demodaten befüllt war (3 Ärzte, darunter Frau Marie PELISSIER; 4 Clients, darunter Brigitte BISTROU; und die beiden Konten admin/admin und user/user).

6.12.1. 1. Anmeldebildschirm

Solange sich der Benutzer nicht angemeldet hat, wird nur der Anmeldebildschirm angezeigt – der Rest der Anwendung (Arzt-/Tag-Auswahl, Kalender) erscheint noch nicht auf der Seite. Die beiden Buttons „FR“ und „EN“ in der Kopfzeile sind in diesem Stadium jedoch bereits nutzbar – für den Sprachwechsel ist kein Token erforderlich:

Image

Login Screen

Ein Versuch mit falschem Passwort zeigt eine Fehlermeldung ohne weitere Details an (um nicht zu verraten, ob das Problem beim Benutzernamen oder beim Passwort liegt):

Image

Login error

Ein Klick auf „FR“ übersetzt den Bildschirm sofort, einschließlich dieser Fehlermeldung, falls sie beim Sprachwechsel gerade angezeigt wird – eine direkte Folge der weiter oben in diesem Kapitel erläuterten Entscheidung (Abschnitt login.component.ts), in error() einen Übersetzungsschlüssel statt eines bereits aufgelösten englischen Textes zu speichern:

Image

Login screen in French

6.12.2. 2. Anmeldung als Administrator (Rolle ADMIN)

Nach der Anmeldung mit dem Konto admin/admin zeigt die Kopfzeile die Rolle (Badge „ADMIN“) und den Namen des Benutzers sowie einen Button „Log out“ an. Die Arzt-/Tag-Auswahl erscheint genau wie vor der Authentifizierung:

Image

Home, once logged in as ADMIN

Die französische Oberfläche bleibt auch nach der Anmeldung verfügbar; dann übersetzt sie auch das Rollen-Badge, die Beschriftungen der Namen und den Button „Log out“:

Image

Home page, after logging in to ADMIN, in French

Nachdem Sie einen Arzt ausgewählt und auf „View schedule“ geklickt haben, hat jedes freie Zeitfenster einen Button „Book“ und jedes gebuchte Zeitfenster einen Button „Cancel“: Die Rolle ADMIN hat vollen Zugriff, genau wie vor der Einführung der Rollen:

Image

Calendar, ADMIN view (Book/Cancel buttons visible)

Ein Klick auf „Book“ öffnet das modale Bootstrap-Fenster, in dem Sie aufgefordert werden, einen Patienten auszuwählen:

Image

Booking window (Bootstrap modal)

Nachdem Sie einen Patienten ausgewählt und auf „Confirm“ geklickt haben, schließt sich das Fenster und der Kalender wird automatisch aktualisiert: Das gebuchte Zeitfenster erscheint nun als belegt, mit dem Namen des ausgewählten Patienten:

Image

Calendar after booking

Ein Klick auf „Cancel“ (wenn das Zeitfenster gebucht ist) aktualisiert den Kalender auf dieselbe Weise – das Zeitfenster kehrt zu „Free“ zurück:

Image

Calendar after cancellation

6.12.3. 3. Anmeldung als Benutzer (Rolle USER, nur lesend)

Nach der Abmeldung zeigt die Anmeldung mit dem Konto user/user ein anderes Badge „USER“ an:

Image

Home screen, once logged in as USER

Der Kalender bleibt einsehbar, aber es erscheinen keine Buttons „Book“/„Cancel“: Die Aktionsspalte ist für jedes Zeitfenster leer. Eine direkte Anfrage an den Server (zum Beispiel mit Postman unter Angabe des Tokens des Benutzers) würde weiterhin eine Antwort 403 Forbidden erhalten – das Ausblenden der Buttons ist lediglich eine Komfortfunktion der Anzeige; die eigentliche Einschränkung wird serverseitig durch [RolesGuard] durchgesetzt (Kapitel 3):

Image

Calendar, USER view (read-only, no action buttons)

6.13. Was außerhalb des Umfangs bleibt oder zurückgestellt wird

Der „Debug“-Modus (Anzeige des rohen Templates der aktuellen Ansicht) des ursprünglichen AngularJS-1.x-Clients ist ein Feature, das in diesem Port bewusst weggelassen wurde – er wird in einer späteren Phase des Kurses nicht auftauchen (die Begründung dieser Entscheidung finden Sie in Kapitel 6, Fazit). Das Festlegen einer künstlichen Netzwerkverzögerung wird dagegen tatsächlich auf eine spätere Phase verschoben.