10. Fallstudie: Der Angular-Client für die Anwendung RdvMedecins
10.1. Die Aufgabenstellung
Die Anwendung [RdvMedecins] ermöglicht es, Termine in einer Arztpraxis zu vereinbaren. Im [NestJS]-Kurs wurde sie als HTML-Anwendung geschrieben, in der der Server die Seiten erzeugte. Hier schreiben wir den Client [Angular]: dieselben Seiten, im Browser erzeugt aus den JSON-Daten des Servers, der im Kapitel „Der RdvMedecins-Server: eine Blackbox“ beschrieben wurde.
Der Client muss alles bieten, was die HTML-Anwendung bot:
- eine durch ein CAPTCHA geschützte Anmeldeseite mit der Möglichkeit, ein Patientenkonto anzulegen;
- der Terminkalender eines Arztes für einen bestimmten Tag, mit Terminbuchung (Fenster zur Patientenauswahl) und Stornierung;
- für den Administrator die Verwaltung von Ärzten und Kunden (Liste, Hinzufügen, Bearbeiten, Löschen);
- für den Patienten ein persönliches Dashboard (mit den anstehenden Terminen, die er stornieren kann) und die Kontoverwaltung;
- zwei Sprachen: Französisch und Englisch;
- eindeutige URLs ([/schedule?doctorId=1&day=...]), die neu geladen, als Lesezeichen gespeichert und mit den Vor-/Zurück-Schaltflächen des Browsers aufgerufen werden können.
10.2. Installation und Ausführung
Der JSON-Server muss installiert sein und laufen (siehe Kapitel „Der RdvMedecins-Server: eine Blackbox“). Um den Client in einem Browser zu verwenden, benötigen Sie den CAPTCHA-Testmodus nicht: Sie können das Feld [CAPTCHA_TEST] in der Datei [.env] auf dem Server leer lassen.
In einem Konsolenfenster, das im Ordner [rdvmedecins-angular] geöffnet ist:
öffnen Sie dann http://localhost:4200 in einem Browser. Die Demo-Konten sind auf der Anmeldeseite aufgelistet (Passwort = Login).
Die Beispiele verwenden ebenfalls Port 4200: Beenden Sie zuerst das gerade laufende Beispiel ([Ctrl-C]). Sie können den Client auch auf einem anderen Port starten: [npm start -- --port 4300].
10.3. Verwendung der Anwendung
10.3.1. Die Anmeldeseite

Falsches Passwort: Am unteren Seitenrand erscheint eine Meldung, und es wird ein neues Bild angezeigt (jedes Bild kann nur einmal verwendet werden):

10.3.2. Der Terminkalender aus Sicht des Administrators und der Ärzte
Wenn Sie als [admin] angemeldet sind, gelangen Sie zum Terminkalender:

Wählen Sie einen Arzt und einen Tag aus und klicken Sie dann auf „View schedule“. Die URL wird zu [/schedule?doctorId=1&day=2026-10-05]:

„Book“ öffnet das Buchungsfenster. Die URL wird zu [/schedule?doctorId=1&day=2026-10-05&book=3]: Ein Neuladen der Seite (F5) öffnet dasselbe Fenster erneut.

Der Termin ist gespeichert:

„Cancel“ fordert zur Bestätigung auf:

Ein Arzt gelangt direkt zu SEINEM EIGENEN Tagesplan:

10.3.3. Das Patientenportal
Ein Patient ([martin]) gelangt zu „My area“:

Im Terminkalender sieht er neben den Terminen anderer Patienten „Booked“:

Er bucht einen Termin für sich selbst, ohne einen Patienten auszuwählen:

Sein Termin erscheint unter seinem Namen; die Schaltfläche „Book“ ist nicht mehr verfügbar (nur ein anstehender Termin), und eine Meldung erklärt den Grund:

Sein Dashboard zeigt Folgendes:

„Manage my account“: Jede Änderung erfordert das aktuelle Passwort; die Fehler kommen vom Server:

Wenn er die Adresse /doctors aufruft, die dem Administrator vorbehalten ist:

10.3.4. Verwaltung von Ärzten und Kunden

Eine fehlerhaft ausgefüllte Eingabe:

Ein erfolgreiches Hinzufügen:

Ein Namensvetter:

Die Anfrage, einen Arzt mit vereinbarten Terminen zu löschen, wird abgelehnt:

10.3.5. Ein Konto erstellen
Geben Sie auf der Anmeldeseite das CAPTCHA ein und klicken Sie dann auf „Create a patient account“. Das fehlerhaft ausgefüllte Formular wird daraufhin vom Server abgelehnt:

Sobald das Konto erstellt ist, kehren Sie zur Anmeldeseite zurück; die Anmeldefelder sind vorausgefüllt:

10.3.6. Auf Französisch
Die Schaltflächen FR / EN übersetzen die Seite auf der Stelle, ohne Anfragen an den Server zu senden; auch der Titel des Browser-Tabs wird übersetzt:

10.3.7. Abgelaufene Sitzung, unbekannte Adresse
Läuft das Token ab (oder wird der Cookie gelöscht), erhält die nächste Anfrage eine 401-Antwort; der Client wird zur Anmeldeseite umgeleitet:

Eine unbekannte Adresse:

10.4. Architektur des Clients
| rdvmedecins-angular/
├── angular.json, package.json, tsconfig.json, proxy.conf.json
├── public/favicon.svg the tab icon
└── src/
├── index.html THE page of the application
├── main.ts the startup
├── styles.css
└── app/
├── app.config.ts the configuration of the application
├── app.ts the layout shared by all the pages
├── app.routes.ts the pages and their access rights
├── guards.ts the router guards
├── api/ the API access layer
├── i18n/ the languages
├── services/ session, messages, confirmation, forms
├── pipes/ the formatting
├── components/ the reusable components
└── pages/ the pages
|

Die folgende Tabelle vergleicht die HTML-Anwendung aus dem [NestJS]-Kurs mit diesem Client:
HTML-Anwendung (NestJS) | Angular-Client |
Der Server erzeugt jede Seite ([res.render]) | Der Server liefert JSON; die Komponenten in [src/app/pages/] erzeugen die Seiten |
[views/layout.hbs] und seine Partial Views | [app.ts] und die Komponenten in [src/app/components/] |
die Controller-Routen ([@Get('my-area')]) | Client-Routen ([app.routes.ts]); der Server hat nur /api/...-Routen |
[JwtAuthGuard] und [RolesGuard] leiten zu /login oder zu einer 403-Seite um | Router-Guards; der Server unterhält seine eigenen Guards, die 401 oder 403 zurückgeben |
Flash-Meldung in einem Cookie | Flash-Meldung in einem Service, [MessagesService] |
vom Server gelesene Wörterbücher, Helper [{{t}}] | Wörterbücher im Client, [ngx-translate]; der Server liefert nur Schlüssel |
in einem Cookie gespeicherte Sprache | in [localStorage] gespeicherte Sprache |
abgelehntes Formular: Der Server lädt die Seite neu | abgelehntes Formular: 400/409-Antwort; der Client zeigt die Fehler unterhalb der Felder an |
Bestätigungsfenster: ein kleines Skript, [public/js/app.js] | ein Service und eine Komponente, [ConfirmDialog] |
Die Anwendung funktioniert ohne JavaScript | Die Anwendung IST JavaScript |
Der Client [Vue.js] aus der vorherigen Lektion hat exakt dieselbe Struktur: Die „Stores“ ([Pinia]) sind zu Services geworden, die „Composables“ zu Services oder Funktionen, und die Views zu Seiten.
Alle Dateien des Clients werden unten gezeigt. Sie sind ausführlich kommentiert; diese Kommentare sind Teil des Kurses.
10.4.1. Projektkonfiguration
10.4.1.1. package.json
| {
"name": "rdvmedecins-angular",
"version": "1.0.0",
"description": "Angular client of the medical appointment booking application [RdvMedecins] - client of the JSON server [rdvmedecins-nestjs-json]",
"private": true,
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build"
},
"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",
"@ngx-translate/core": "^18.0.0",
"bootstrap": "^5.3.8",
"rxjs": "~7.8.0",
"tslib": "^2.8.0"
},
"devDependencies": {
"@angular/build": "^22.2.0",
"@angular/cli": "^22.2.0",
"@angular/compiler-cli": "^22.2.0",
"typescript": "~6.0.2"
}
}
|
- Zeilen 8–9: [npm start] startet den Entwicklungsserver; [npm run build] erstellt die Produktionsversion;
- Zeilen 11–22: die von der Anwendung verwendeten Bibliotheken: die von [Angular], [ngx-translate], [Bootstrap] und [RxJS];
- Zeilen 23–28: die Entwicklungswerkzeuge: der [Angular]-Compiler, der Befehl [ng] und [TypeScript].
10.4.1.2. angular.json
| {
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"version": 1,
"cli": {
"packageManager": "npm",
"analytics": false
},
"projects": {
"rdvmedecins-angular": {
"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": {
"budgets": [
{ "type": "initial", "maximumWarning": "800kB", "maximumError": "1MB" },
{ "type": "anyComponentStyle", "maximumWarning": "4kB", "maximumError": "8kB" }
],
"outputHashing": "all"
},
"development": {
"optimization": false,
"extractLicenses": false,
"sourceMap": true
}
},
"defaultConfiguration": "production"
},
"serve": {
"builder": "@angular/build:dev-server",
"options": {
"proxyConfig": "proxy.conf.json"
},
"configurations": {
"production": { "buildTarget": "rdvmedecins-angular:build:production" },
"development": { "buildTarget": "rdvmedecins-angular:build:development" }
},
"defaultConfiguration": "development"
}
}
}
}
}
|
Diesmal nur ein Projekt, im Stammverzeichnis des Ordners (Zeile 11):
- Zeile 18: der Einstiegspunkt der Anwendung;
- Zeile 20: Der Inhalt des Ordners [public] wird unverändert in die erstellte Anwendung kopiert (das Icon);
- Zeile 21: die globalen Stylesheets: das von [Bootstrap], gefolgt von unserem;
- Zeilen 24–30: die Produktionskonfiguration. Die Budgets lösen eine Warnung (oder einen Fehler) aus, wenn die Anwendung die angegebene Größe überschreitet; [outputHashing] fügt dem Namen jeder Datei einen Inhalts-Fingerabdruck hinzu (siehe Kapitel „Bereitstellung“);
- Zeile 37: [ng build] erstellt standardmäßig die Produktionsversion;
- Zeile 42: der Proxy des Entwicklungsservers;
- Zeile 48: [ng serve] verwendet die Entwicklungskonfiguration (nicht optimierter Code, „Source Maps“ für den Debugger).
10.4.1.3. tsconfig.json, tsconfig.app.json, proxy.conf.json
| {
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"skipLibCheck": true,
"isolatedModules": true,
"experimentalDecorators": true,
"importHelpers": true,
"resolveJsonModule": true,
"target": "ES2022",
"module": "preserve"
},
"angularCompilerOptions": {
"strictInjectionParameters": true,
"strictInputAccessModifiers": true,
"strictTemplates": true
},
"files": [],
"references": [
{
"path": "./tsconfig.app.json"
}
]
}
|
- Zeile 3: der strikte Modus von [TypeScript];
- Zeile 14: der Import der JSON-Dateien (der Wörterbücher);
- Zeile 21: Der [Angular]-Compiler prüft auch die Typen in den Templates.
| {
"extends": "./tsconfig.json",
"include": ["src/**/*.ts"]
}
|
| {
"/api": {
"target": "http://localhost:8080",
"secure": false
}
}
|
Der Proxy aus Beispiel 22: Anfragen an /api/... werden an den JSON-Server weitergeleitet.
10.4.2. Start der Anwendung
10.4.2.1. index.html
| <!doctype html>
<!--
index.html - DIE Seite der Anwendung (Single-Page-Anwendung).
Der Server sendet nie eine andere: alles Übrige wird im
Browser von Angular in <app-root> aufgebaut. lang und title werden
von der Anwendung je nach Sprache und angezeigter Seite aktualisiert.
-->
<html lang="en">
<head>
<meta charset="utf-8">
<title>RdvMedecins</title>
<base href="/">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="favicon.svg" type="image/svg+xml">
</head>
<body>
<app-root></app-root>
<!-- ohne JavaScript kann eine Angular-Anwendung nichts anzeigen: Wir weisen darauf hin -->
<noscript>RdvMedecins requires JavaScript. / RdvMedecins a besoin de JavaScript.</noscript>
</body>
</html>
|
- Zeile 17: das Element, in dem [Angular] die Root-Komponente anzeigt;
- Zeile 19: Ohne [JavaScript] kann eine [Angular]-Anwendung nichts anzeigen: Wir sagen dies ausdrücklich.
10.4.2.2. src/main.ts
| // =========================================================================
// main.ts - der Start der Anwendung
// -------------------------------------------------------------------------
// Die Wurzelkomponente (App) und die Konfiguration der Anwendung
// (app.config.ts). Die Stylesheets (Bootstrap, styles.css) sind
// in angular.json deklariert.
// =========================================================================
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
import { appConfig } from './app/app.config';
bootstrapApplication(App, appConfig).catch((error) => console.error(error));
|
10.4.2.3. src/app/app.config.ts
| // =========================================================================
// app.config.ts - die Konfiguration der Anwendung
// -------------------------------------------------------------------------
// - der Router, seine Routen (app.routes.ts), die an die Inputs der Seiten
// übergebenen Routenparameter und der übersetzte Tab-Titel;
// - HttpClient, mit dem Interceptor für die Fehler und den 401;
// - ngx-translate (Französisch und Englisch).
// =========================================================================
import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { provideRouter, TitleStrategy, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';
import { apiInterceptor } from './api/api.interceptor';
import { provideI18n } from './i18n/i18n';
import { TranslatedTitle } from './i18n/title.strategy';
export const appConfig: ApplicationConfig = {
providers: [
// die unbehandelten Fehler werden in der Browser-Konsole gemeldet
provideBrowserGlobalErrorListeners(),
provideRouter(routes, withComponentInputBinding()),
{ provide: TitleStrategy, useClass: TranslatedTitle },
provideHttpClient(withInterceptors([apiInterceptor])),
provideI18n(),
],
};
|
- Zeile 21: Nicht behandelte Fehler (etwa ein abgelehntes Promise, auf das niemand wartet) werden in der Browser-Konsole gemeldet;
- Zeile 22: der Router, wobei die Routenparameter an die Inputs der Seite übergeben werden (Beispiel 17);
- Zeile 23: [TitleStrategy] ist der Router-Service, der nach jeder Navigation den Titel des Tabs festlegt. Wir ersetzen den Service von [Angular] durch unseren eigenen ([i18n/title.strategy.ts]), der den Titel übersetzt. Genau darin liegt der Sinn der Dependency Injection: Sie können die Klasse des Frameworks durch Ihre eigene Klasse ersetzen, ohne etwas anderes zu ändern;
- Zeile 24: der HTTP-Client mit unserem Interceptor;
- Zeile 25: [ngx-translate].
10.4.2.4. src/app/app.ts
| // =========================================================================
// app.ts - die Wurzelkomponente: das allen Seiten gemeinsame LAYOUT
// -------------------------------------------------------------------------
// Das Äquivalent von views/layout.hbs der HTML-Anwendung:
// - die Navigationsleiste;
// - eine Erfolgsmeldung OBEN;
// - die aktuelle Seite (<router-outlet>);
// - das Fehlerfeld UNTEN;
// - der Bestätigungsdialog, einmal für die ganze Anwendung.
// =========================================================================
import { Component } from '@angular/core';
import { RouterOutlet } from '@angular/router';
import { NavBar } from './components/nav-bar/nav-bar';
import { SuccessMessage } from './components/success-message';
import { ErrorPanel } from './components/error-panel';
import { ConfirmDialog } from './components/confirm-dialog/confirm-dialog';
@Component({
selector: 'app-root',
imports: [RouterOutlet, NavBar, SuccessMessage, ErrorPanel, ConfirmDialog],
template: `
<div class="container py-4">
<app-nav-bar />
<app-success-message />
<router-outlet />
<app-error-panel />
</div>
<app-confirm-dialog />
`,
})
export class App {}
|
- Zeilen 22–30: das allen Seiten gemeinsame Template: die Navigationsleiste, die Erfolgsmeldung, die aktuelle Seite, der Fehlerbereich und das Bestätigungsfenster (Beispiel 16).
10.4.2.5. src/styles.css
| /* =========================================================================
styles.css - einige Einstellungen zusätzlich zu Bootstrap
(übernommen aus public/css/styles.css der HTML-Anwendung)
========================================================================= */
body {
background-color: #f5f7fa;
}
.free-slot:hover {
background-color: #e9f7ef;
}
/* -------------------------------------------------------------------------
.error-panel: die Fehlermeldungen am unteren Seitenrand, auf hellrosa
Hintergrund (siehe components/error-panel.ts).
position: sticky + bottom: ist die Seite höher als das Fenster, bleibt das
Panel am unteren Fensterrand haften, statt unterhalb des
sichtbaren Bereichs zu verschwinden - ohne jemals den Inhalt zu verdecken, wenn die Seite
kurz ist. z-index: über dem ausgegrauten Hintergrund der modalen Dialoge.
pointer-events: none: das Panel enthält nichts Anklickbares; überlappt es
einen Button, geht der Klick durch es hindurch.
------------------------------------------------------------------------- */
.error-panel {
position: sticky;
bottom: 1rem;
z-index: 1060;
pointer-events: none;
margin-top: 1.5rem;
padding: 0.75rem 1rem;
background-color: #fdecef; /* helles Rosa */
border: 1px solid #f5c2c7;
border-radius: 0.375rem;
color: #842029;
}
/* die zwei großen Optionen der Seite "Mein Bereich" des Patienten */
.option-card {
transition: border-color 0.15s, box-shadow 0.15s;
}
.option-card:hover {
border-color: #0d6efd;
box-shadow: 0 0.25rem 0.75rem rgba(13, 110, 253, 0.15);
}
/* das Captcha-Bild (SVG von 150 x 50 Pixeln), eingefügt per [innerHTML]:
nur ein GLOBALER Style wie dieser kann es erreichen */
.captcha-image svg {
display: block;
border: 1px solid #dee2e6;
border-radius: 0.375rem;
}
|
- Zeilen 24–35: der Fehlerbereich am unteren Seitenrand;
- Zeilen 49–53: das CAPTCHA-Bild. Wie in Beispiel 24 wird ein [<svg>] , das durch [[innerHTML]] eingefügt wird, nur durch einen globalen Stil formatiert.
10.4.3. Die Zugriffsschicht für die API
10.4.3.1. src/app/api/types.ts
| // =========================================================================
// api/types.ts - die mit dem Server ausgetauschten JSON-Objekte
// -------------------------------------------------------------------------
// Die Übersetzung der im Kapitel "Der Server, eine Blackbox" beschriebenen API
// in TypeScript-Interfaces. Der Compiler prüft so, dass der Client
// nur Felder verwendet, die wirklich existieren.
// =========================================================================
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;
}
// ein Titel, ein Vorname, ein Nachname
export interface Identity {
title: string;
firstName: string;
lastName: string;
}
// ein Arzt oder ein Kunde: GET /api/doctors, GET /api/clients/:id...
export interface Person extends Identity {
id: number;
version: number; // optimistisches Sperren: bei einer Aktualisierung mitzusenden
login?: string; // nur für den ADMIN
}
// was zum Anlegen / Aktualisieren einer Person gesendet wird (ADMIN)
export interface PersonData extends Identity {
login: string; // '' = Standardwert (Anlegen) oder unverändert (Aktualisieren)
password: string; // genauso
version?: number;
}
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)
}
// GET /api/my-area
export interface MyArea {
patient: Identity;
appointments: { id: number; day: string; slot: Slot; doctor: Person }[];
}
// GET /api/my-account
export interface MyAccount extends Identity {
login: string;
version: number;
}
// PUT /api/my-account
export interface MyAccountUpdate extends Identity {
login: string;
password: string; // '' = unverändert
confirmation: string;
currentPassword: string;
version: number;
}
// POST /api/register
export interface Registration extends Identity {
login: string;
password: string;
confirmation: string;
}
|
Die Übersetzung der im Kapitel „Der RdvMedecins-Server, eine Blackbox“ beschriebenen API in [TypeScript]-Interfaces. Das Schlüsselwort [extends] vermeidet die Wiederholung gemeinsamer Felder: Eine [Person] ist eine [Identity] (Anrede, Vorname, Nachname) mit einem Bezeichner und einer Version.
10.4.3.2. src/app/api/api-error.ts
| // =========================================================================
// api/api-error.ts - EINE Klasse für alle Fehler der API
// -------------------------------------------------------------------------
// Übernommen aus common/api-error.ts der Beispiele. Jeder Fehler einer Anfrage
// (Antwort 4xx / 5xx des Servers, nicht erreichbarer Server, Antwort eines Proxys)
// wird zu einem ApiError, der den Übersetzungs-KEY der Meldung, ihre
// Parameter und den Fehler jedes Felds eines abgelehnten Formulars trägt.
// =========================================================================
import { HttpErrorResponse } from '@angular/common/http';
export class ApiError extends Error {
constructor(
public readonly statusCode: number, // 0: der Server hat nicht geantwortet
public readonly key: string, // Übersetzungsschlüssel: 'ERRORS.LOGIN_TAKEN'
public readonly params: Record<string, string> = {},
public readonly fields: Record<string, string> = {}, // Fehler jedes Felds
) {
super(key);
this.name = 'ApiError';
}
}
export function toApiError(e: unknown): ApiError {
if (e instanceof ApiError) {
return e;
}
if (!(e instanceof HttpErrorResponse)) {
return new ApiError(0, 'ERRORS.SERVER_ERROR');
}
const body = (typeof e.error === 'object' && e.error !== null ? e.error : {}) as {
key?: string;
params?: Record<string, string>;
fields?: Record<string, string>;
};
return new ApiError(
e.status,
// kein key: nicht unser Server hat geantwortet, sondern das Netzwerk
// oder ein Proxy (ng serve: 500 ohne Body; nginx: 502, 504...)
body.key ?? (e.status === 0 || e.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR'),
body.params,
body.fields,
);
}
|
Die Datei [common/api-error.ts] aus Beispiel 24.
10.4.3.3. src/app/api/api.interceptor.ts
| // =========================================================================
// api/api.interceptor.ts - der Interceptor ALLER Anfragen an die API
// -------------------------------------------------------------------------
// Übernommen aus common/errors.interceptor.ts der Beispiele, mit einer Neuerung:
// der zentralen Behandlung der Antwort 401.
//
// Ein 401 kann jederzeit eintreffen: Das Token ist abgelaufen (2 Stunden), das
// Konto wurde gelöscht, der Server wurde mit einem anderen geheimen
// Schlüssel neu gestartet... Statt diesen Fall in jeder Komponente zu behandeln, behandeln wir ihn
// HIER, einmal: Wir vergessen den Benutzer, bereiten die Meldung
// "Sitzung abgelaufen" vor und gehen zur Login-Seite zurück.
//
// Manche Anfragen behandeln ihr 401 selbst (der Login, GET
// /api/auth/me...): Sie teilen das mit einem CONTEXT-TOKEN
// (HttpContextToken) mit, einer an die Anfrage angehängten Information, die
// der Interceptor liest (siehe api/rdvmedecins.api.ts).
// =========================================================================
import { inject } from '@angular/core';
import { HttpContextToken, HttpInterceptorFn } from '@angular/common/http';
import { Router } from '@angular/router';
import { catchError, throwError } from 'rxjs';
import { toApiError } from './api-error';
import { SessionService } from '../services/session.service';
import { MessagesService } from '../services/messages.service';
// true: die Anfrage behandelt ein mögliches 401 selbst (standardmäßig false)
export const IGNORE_401 = new HttpContextToken<boolean>(() => false);
export const apiInterceptor: HttpInterceptorFn = (req, next) => {
// inject: die Services, die benötigt werden (im Injektionskontext
// des Interceptors, BEVOR die Anfrage gesendet wird)
const session = inject(SessionService);
const messages = inject(MessagesService);
const router = inject(Router);
return next(req).pipe(
catchError((e: unknown) => {
const error = toApiError(e);
if (error.statusCode === 401 && !req.context.get(IGNORE_401)) {
session.forget();
messages.flash('error', 'ERRORS.SESSION_EXPIRED');
router.navigate(['/login']);
}
return throwError(() => error);
}),
);
};
|
Der Interceptor aus Beispiel 24, mit einer neuen Funktion: der zentralen Behandlung der 401-Antwort. Ein 401 kann jederzeit auftreten: Das Token ist abgelaufen, das Konto wurde gelöscht ... Anstatt diesen Fall auf jeder Seite zu behandeln, behandeln wir ihn hier, einmalig.
- Zeile 28: ein Kontext-Token ([HttpContextToken]) – eine an eine Anfrage angehängte Information, die der Interceptor lesen kann. Standardmäßig ist es auf [false] gesetzt;
- Zeilen 33–35: Der Interceptor injiziert die Services, die er benötigt. [inject] muss am Anfang der Funktion aufgerufen werden: Später, in [catchError], existiert der Injektionskontext nicht mehr;
- Zeile 39: Jeder Fehler wird zu einem [ApiError];
- Zeilen 40–44: eine 401-Antwort auf eine Anfrage, die sie nicht selbst behandelt: Der Benutzer wird vergessen, die Meldung „Sitzung abgelaufen“ wird vorbereitet (sie wird auf der nächsten Seite angezeigt), und der Benutzer wird zur Anmeldeseite umgeleitet;
- Zeile 45: Der Fehler wird in jedem Fall an den Code weitergereicht, der die Anfrage gestellt hat.
10.4.3.4. src/app/api/rdvmedecins.api.ts
| // =========================================================================
// api/rdvmedecins.api.ts - eine Methode pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients: Die Komponenten rufen diese
// typisierten Methoden auf, ohne etwas über die URLs, HttpClient oder JSON zu wissen. Ändert sich
// die API, ändert sich nur diese Datei.
// Jede Methode liefert ein PROMISE (firstValueFrom): Die Komponenten
// verketten die Anfragen mit async / await. Bei einem Fehler wird das Promise
// mit einem ApiError abgelehnt (siehe api.interceptor.ts).
// =========================================================================
import { inject, Injectable } from '@angular/core';
import { HttpClient, HttpContext, HttpParams } from '@angular/common/http';
import { firstValueFrom } from 'rxjs';
import { IGNORE_401 } from './api.interceptor';
import {
Schedule,
Captcha,
PersonData,
Registration,
MyAccountUpdate,
MyAccount,
MyArea,
Person,
User,
} from './types';
// /api/doctors oder /api/clients: beide werden gleich behandelt
export type PersonType = 'doctors' | 'clients';
type Empty = Record<string, never>;
type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
@Injectable({ providedIn: 'root' })
export class RdvMedecinsApi {
private readonly http = inject(HttpClient);
// die Anfrage selbst; isPublic: true für die Routen, die
// das 401 selbst behandeln (öffentliche Routen, GET /api/auth/me)
private request<T>(method: Method, url: string, body?: unknown, isPublic = false, params?: HttpParams): Promise<T> {
return firstValueFrom(
this.http.request<T>(method, `/api${url}`, {
body,
params,
context: new HttpContext().set(IGNORE_401, isPublic),
}),
);
}
// ———————————————————————————————— Login (öffentliche Routen)
captcha(): Promise<Captcha> {
return this.request<Captcha>('GET', '/captcha', undefined, true);
}
me(): Promise<User> {
return this.request<User>('GET', '/auth/me', undefined, true);
}
logIn(login: string, password: string, captchaId: string, captcha: string): Promise<User> {
return this.request<User>('POST', '/auth/login', { login, password, captchaId, captcha }, true);
}
logOut(): Promise<Empty> {
return this.request<Empty>('POST', '/auth/logout', {}, true);
}
// ———————————————————————————————— Kontoerstellung (öffentlich)
registrationAccess(captchaId: string, captcha: string): Promise<Empty> {
return this.request<Empty>('POST', '/register/access', { captchaId, captcha }, true);
}
registrationAccessStatus(): Promise<{ valid: boolean }> {
return this.request<{ valid: boolean }>('GET', '/register/access', undefined, true);
}
register(data: Registration): Promise<{ login: string }> {
return this.request<{ login: string }>('POST', '/register', data, true);
}
// ———————————————————————————————— Terminkalender und Termine
// doctorId null: bei einem angemeldeten Arzt SEIN bzw. IHR Terminkalender
schedule(doctorId: number | null, day: string): Promise<Schedule> {
let params = new HttpParams().set('day', day);
if (doctorId !== null) {
params = params.set('doctorId', doctorId);
}
return this.request<Schedule>('GET', '/schedule', undefined, false, params);
}
book(day: string, slotId: number, clientId: number | null): Promise<{ id: number }> {
return this.request<{ id: number }>('POST', '/appointments', { day, slotId, clientId: clientId ?? undefined });
}
cancelAppointment(appointmentId: number): Promise<Empty> {
return this.request<Empty>('DELETE', `/appointments/${appointmentId}`);
}
// ———————————————————————————————— Ärzte und Kunden
list(type: PersonType): Promise<Person[]> {
return this.request<Person[]>('GET', `/${type}`);
}
read(type: PersonType, id: number): Promise<Person> {
return this.request<Person>('GET', `/${type}/${id}`);
}
add(type: PersonType, data: PersonData): Promise<Person> {
return this.request<Person>('POST', `/${type}`, data);
}
edit(type: PersonType, id: number, data: PersonData): Promise<Person> {
return this.request<Person>('PUT', `/${type}/${id}`, data);
}
remove(type: PersonType, id: number): Promise<Empty> {
return this.request<Empty>('DELETE', `/${type}/${id}`);
}
// ———————————————————————————————— der Bereich des Patienten
myArea(): Promise<MyArea> {
return this.request<MyArea>('GET', '/my-area');
}
myAccount(): Promise<MyAccount> {
return this.request<MyAccount>('GET', '/my-account');
}
editMyAccount(data: MyAccountUpdate): Promise<User> {
return this.request<User>('PUT', '/my-account', data);
}
deleteMyAccount(currentPassword: string): Promise<Empty> {
return this.request<Empty>('DELETE', '/my-account', { currentPassword });
}
}
|
Die API-Zugriffsschicht: eine Methode pro Route.
- Zeilen 40–48: Eine einzige Methode verarbeitet alle Anfragen. [http.request] akzeptiert die HTTP-Methode als Parameter; [firstValueFrom] wandelt das Ergebnis in ein Promise um;
- Zeile 45: Die Anfrage trägt das Kontext-Token [IGNORE_401]: true für Routen, die den 401 selbst behandeln. Ein falsches Passwort liefert einen 401: Das ist keine abgelaufene Sitzung! Ebenso [GET /api/auth/me] liefert einen 401, wenn niemand angemeldet ist, was normal ist;
- Zeilen 77–83: [HttpParams] erzeugt die URL-Parameter (?day=...&doctorId=...). Ein Objekt [HttpParams] ändert sich nicht: [set] gibt ein neues Objekt zurück;
- Zeile 85: [clientId ?? undefined]: Wenn eine [clientId] fehlt, wird sie gar nicht gesendet;
- Zeilen 92–106: Ärzte und Kunden werden auf dieselbe Weise behandelt: Der Typ (['doctors'] oder ['clients']) ist Teil der Adresse;
- Zeile 119: ein DELETE mit einem Body, der das aktuelle Passwort enthält, das zum Löschen des Kontos erforderlich ist.
10.4.4. Sprachen
10.4.4.1. src/app/i18n/i18n.ts
| // =========================================================================
// i18n/i18n.ts - Französisch und Englisch (ngx-translate, siehe Beispiel 21)
// -------------------------------------------------------------------------
// Die Wörterbücher fr.json und en.json sind die des NestJS-Kurses
// (i18n/*.json), ergänzt um einige clientspezifische Schlüssel
// (ERRORS.SERVER_UNREACHABLE...). Der JSON-Server liefert nur SCHLÜSSEL
// ('ERRORS.LOGIN_TAKEN'): Sie sind dieselben wie die der Wörterbücher.
//
// Die gewählte Sprache wird in localStorage gespeichert (eine Einstellung, keine
// sensiblen Daten); andernfalls wird die Sprache des Browsers verwendet.
// =========================================================================
import { Provider } from '@angular/core';
import { provideTranslateLoader, provideTranslateService, TranslateLoader, TranslationObject } from '@ngx-translate/core';
import { Observable, of } from 'rxjs';
import fr from './fr.json';
import en from './en.json';
export type Language = 'fr' | 'en';
export const LANGUAGES: Language[] = ['fr', 'en'];
export const STORAGE_KEY = 'rdvmedecins.language';
// die Wörterbücher gehören zum Code der Anwendung: keine Anfrage
class DictionariesLoader implements TranslateLoader {
getTranslation(language: string): Observable<TranslationObject> {
return of(language === 'en' ? en : fr);
}
}
export function initialLanguage(): Language {
try {
const stored = localStorage.getItem(STORAGE_KEY);
if (stored === 'fr' || stored === 'en') {
return stored;
}
} catch {
// localStorage nicht verfügbar (striktes privates Surfen...): egal
}
return navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en';
}
export function provideI18n(): Provider[] {
return provideTranslateService({
loader: provideTranslateLoader(DictionariesLoader),
fallbackLang: 'en',
lang: initialLanguage(),
});
}
|
Die Konfiguration von [ngx-translate] aus Beispiel 21:
- Zeilen 30–40: Die Ausgangssprache ist die, die der Benutzer zuletzt gewählt hat; andernfalls Französisch, wenn die Sprache des Browsers Französisch ist, und in allen anderen Fällen Englisch. Der Zugriff auf [localStorage] kann fehlschlagen (in bestimmten privaten Browsermodi), deshalb überspringen wir ihn in diesem Fall.
10.4.4.2. src/app/i18n/language.service.ts
| // =========================================================================
// i18n/language.service.ts - die aktuelle Sprache und die Möglichkeit, sie zu ändern
// =========================================================================
import { inject, Injectable } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { STORAGE_KEY, Language } from './i18n';
@Injectable({ providedIn: 'root' })
export class LanguageService {
private readonly translate = inject(TranslateService);
// ein Signal: 'fr' oder 'en'
readonly language = this.translate.currentLang;
constructor() {
document.documentElement.lang = this.translate.getCurrentLang() ?? 'en';
}
// die Sprache ändern: die gesamte Anwendung wird auf einmal neu übersetzt
change(language: Language): void {
this.translate.use(language);
document.documentElement.lang = language;
try {
localStorage.setItem(STORAGE_KEY, language);
} catch {
// ohne Bedeutung
}
}
}
|
- Zeile 13: die aktuelle Sprache, ein Signal;
- Zeilen 20–28: Sprache wechseln: Die Seite wird neu übersetzt (Zeile 21), das Attribut [lang] der Seite wird aktualisiert (Zeile 22), und die Auswahl wird gespeichert (Zeile 24).
10.4.4.3. src/app/i18n/title.strategy.ts
| // =========================================================================
// i18n/title.strategy.ts - der Tab-Titel, übersetzt
// -------------------------------------------------------------------------
// Jede Route deklariert einen Titel (title: 'SCHEDULE.PAGE_TITLE', siehe
// app.routes.ts). Standardmäßig schreibt Angular ihn UNVERÄNDERT in den Tab. Eine
// TitleStrategy ersetzt dieses Verhalten: updateTitle() wird nach
// jeder Navigation aufgerufen; buildTitle() liefert den Titel der angezeigten Route
// (hier einen Schlüssel), den wir übersetzen. Und wenn sich die Sprache ändert, wird der
// letzte Titel erneut übersetzt.
// Die Klasse wird in app.config.ts deklariert:
// { provide: TitleStrategy, useClass: TranslatedTitle }
// =========================================================================
import { inject, Injectable } from '@angular/core';
import { Title } from '@angular/platform-browser';
import { RouterStateSnapshot, TitleStrategy } from '@angular/router';
import { TranslateService } from '@ngx-translate/core';
@Injectable({ providedIn: 'root' })
export class TranslatedTitle extends TitleStrategy {
private readonly title = inject(Title);
private readonly translate = inject(TranslateService);
private key: string | undefined;
constructor() {
super();
this.translate.onLangChange.subscribe(() => this.apply());
}
override updateTitle(snapshot: RouterStateSnapshot): void {
this.key = this.buildTitle(snapshot);
this.apply();
}
private apply(): void {
const application = this.translate.instant('APP.TITLE');
this.title.setTitle(this.key ? `${this.translate.instant(this.key)} - ${application}` : application);
}
}
|
Jede Route deklariert einen Titel, der in diesem Fall ein Übersetzungsschlüssel ('SCHEDULE.PAGE_TITLE') ist. Standardmäßig [Angular] würde ihn unverändert im Tab ausgeben. Diese Klasse ersetzt den Service [TitleStrategy] des Routers (app.config.ts, Zeile 23):
- Zeile 20: Sie erbt von der Klasse [TitleStrategy] von [Angular];
- Zeilen 30–33: [updateTitle] wird vom Router nach jeder Navigation aufgerufen; [buildTitle], das geerbt wird, liefert den Titel, den die angezeigte Route deklariert;
- Zeilen 35–38: der übersetzte Titel, gefolgt vom Namen der Anwendung: „Schedule - RdvMedecins“;
- Zeile 27: Wenn sich die Sprache ändert, wird der letzte Titel neu übersetzt.
10.4.4.4. Die Wörterbücher
Die Wörterbücher [fr.json] und [en.json] stammen aus der HTML-Anwendung des [NestJS]-Kurses, ergänzt um einige clientspezifische Schlüssel ([ERRORS.SERVER_UNREACHABLE] ...). Nur ihre Parametersyntax ändert sich: [{{min}}] statt [ngx-translate]. Der JSON-Server liefert dieselben Schlüssel.
| {
"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"
},
"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"
},
"SCHEDULE": {
"PAGE_TITLE": "Agenda",
"TITLE_PREFIX": "Agenda du",
"COLUMN_SLOT": "Créneau",
"COLUMN_STATUS": "Statut",
"FREE": "Libre",
"BOOK": "Réserver",
"CANCEL_APPOINTMENT": "Annuler",
"CANCEL_CONFIRM": "Annuler ce rendez-vous ?",
"EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda ».",
"NO_SLOTS": "Ce médecin n'a aucun créneau horaire.",
"BOOKED": "Rendez-vous enregistré.",
"CANCELLED": "Rendez-vous annulé.",
"BOOKED_BY_OTHER": "Réservé",
"ALREADY_BOOKED_INFO": "Vous avez déjà un rendez-vous à venir : annulez-le pour en prendre un autre."
},
"BOOKING_DIALOG": {
"TITLE": "Réserver ce créneau",
"CLOSE_ARIA": "Fermer",
"SLOT": "Créneau de {{time}}",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choisir un patient --",
"CANCEL": "Annuler",
"CONFIRM": "Confirmer"
},
"PERSONS": {
"COLUMN_TITLE": "Titre",
"COLUMN_FIRSTNAME": "Prénom",
"COLUMN_LASTNAME": "Nom",
"COLUMN_LOGIN": "Login",
"EDIT": "Modifier",
"DELETE": "Supprimer",
"SAVE": "Enregistrer",
"BACK": "Retour à la liste",
"TITLE_LABEL": "Titre",
"FIRSTNAME_LABEL": "Prénom",
"LASTNAME_LABEL": "Nom",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"LOGIN_HELP_CREATE": "Facultatif : par défaut, le nom en minuscules.",
"LOGIN_HELP_EDIT": "Laisser vide pour ne pas le changer.",
"PASSWORD_HELP_CREATE": "Facultatif : par défaut, identique au login.",
"PASSWORD_HELP_EDIT": "Laisser vide pour ne pas le changer.",
"ACCOUNT_SECTION": "Compte utilisateur"
},
"DOCTORS": {
"TITLE": "Médecins",
"ADD": "Ajouter un médecin",
"EDIT": "Modifier un médecin",
"EMPTY": "Aucun médecin.",
"DELETE_CONFIRM": "Supprimer ce médecin, ses créneaux horaires et son compte utilisateur ?",
"ADDED": "Le médecin {{name}} a été ajouté (login : {{login}}).",
"UPDATED": "Le médecin {{name}} a été modifié.",
"DELETED": "Le médecin {{name}} a été supprimé."
},
"CLIENTS": {
"TITLE": "Clients",
"ADD": "Ajouter un client",
"EDIT": "Modifier un client",
"EMPTY": "Aucun client.",
"DELETE_CONFIRM": "Supprimer ce client, son compte utilisateur et tous ses rendez-vous ?",
"ADDED": "Le client {{name}} a été ajouté (login : {{login}}).",
"UPDATED": "Le client {{name}} a été modifié.",
"DELETED": "Le client {{name}} a été supprimé."
},
"ERROR_PAGE": {
"TITLE": "Erreur",
"BACK": "Retour à l'accueil"
},
"ERRORS": {
"LOGIN_TAKEN": "Ce login est déjà utilisé par un autre compte.",
"DOCTOR_ALREADY_EXISTS": "Un médecin portant ce prénom et ce nom existe déjà.",
"PATIENT_ALREADY_EXISTS": "Un client portant ce prénom et ce nom existe déjà.",
"DOCTOR_HAS_APPOINTMENTS": "Ce médecin a des rendez-vous : annulez-les avant de le supprimer.",
"SLOT_ALREADY_BOOKED": "Ce créneau vient d'être réservé par quelqu'un d'autre.",
"CONCURRENT_UPDATE": "Cette fiche a été modifiée entre-temps par un autre utilisateur. Revenez à la liste et rouvrez-la avant de recommencer.",
"DOCTOR_NOT_FOUND": "Ce médecin n'existe pas (ou plus).",
"PATIENT_NOT_FOUND": "Ce client n'existe pas (ou plus).",
"SLOT_NOT_FOUND": "Ce créneau n'existe pas (ou plus).",
"APPOINTMENT_NOT_FOUND": "Ce rendez-vous n'existe pas (ou plus).",
"INVALID_DATE": "La date demandée n'est pas valide.",
"CHOOSE_PATIENT": "Choisissez un patient.",
"INVALID_FORM": "Le formulaire contient des erreurs.",
"INVALID_TITLE": "Choisissez un titre dans la liste.",
"FIRSTNAME_REQUIRED": "Le prénom est obligatoire.",
"FIRSTNAME_TOO_LONG": "Le prénom ne doit pas dépasser 20 caractères.",
"LASTNAME_REQUIRED": "Le nom est obligatoire.",
"LASTNAME_TOO_LONG": "Le nom ne doit pas dépasser 20 caractères.",
"INVALID_LOGIN": "30 caractères au plus : lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
"PASSWORD_TOO_LONG": "Le mot de passe ne doit pas dépasser 72 caractères.",
"SESSION_EXPIRED": "Votre session a expiré : reconnectez-vous.",
"BAD_REQUEST": "La requête est invalide.",
"FORBIDDEN": "Votre rôle ne vous permet pas d'accéder à cette page.",
"NOT_FOUND": "Cette page n'existe pas.",
"SERVER_ERROR": "Une erreur inattendue s'est produite. Réessayez plus tard.",
"TOO_MANY_ATTEMPTS": "Trop de tentatives infructueuses. Réessayez dans {{minutes}} minute(s).",
"WRONG_CAPTCHA": "Les caractères recopiés ne correspondent pas à l'image. Une nouvelle image vous est proposée.",
"TOO_MANY_ACCOUNTS": "Trop de comptes ont été créés depuis votre connexion. Réessayez dans {{minutes}} minute(s).",
"LOGIN_REQUIRED": "Le login est obligatoire.",
"PASSWORD_REQUIRED": "Le mot de passe est obligatoire.",
"PASSWORD_TOO_SHORT": "Le mot de passe doit comporter au moins {{min}} caractères.",
"CONFIRMATION_REQUIRED": "Confirmez le mot de passe.",
"PASSWORDS_DIFFER": "La confirmation ne correspond pas au mot de passe.",
"CURRENT_PASSWORD_REQUIRED": "Saisissez votre mot de passe actuel.",
"WRONG_CURRENT_PASSWORD": "Mot de passe actuel incorrect.",
"PAST_DATE": "On ne peut pas prendre de rendez-vous à une date passée.",
"PATIENT_HAS_UPCOMING_APPOINTMENT": "Ce patient a déjà un rendez-vous à venir : il faut l'annuler avant d'en prendre un autre.",
"CAPTCHA_BEFORE_ACCOUNT": "Pour créer un compte, recopiez d'abord correctement les caractères de l'image, puis cliquez sur « Créer un compte client ».",
"AUTH_REQUIRED": "Connectez-vous pour accéder à cette page.",
"JSON_REQUIRED": "Requête refusée : le serveur attend du JSON.",
"SERVER_UNREACHABLE": "Le serveur ne répond pas. Réessayez plus tard."
},
"CAPTCHA": {
"LABEL": "Recopiez les caractères de l'image",
"IMAGE_ALT": "Image de vérification anti-robots",
"NEW_IMAGE": "Autre image",
"HELP": "Majuscules ou minuscules, peu importe."
},
"REGISTRATION": {
"TITLE": "Créer un compte client",
"INTRO": "Ce compte vous permettra de prendre vous-même vos rendez-vous.",
"LOGIN_HELP": "Lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
"PASSWORD_HELP": "Au moins {{min}} caractères.",
"SUBMIT": "Créer mon compte",
"BACK_TO_LOGIN": "Retour à la connexion",
"DONE": "Votre compte a été créé. Vous pouvez vous connecter avec le login {{login}}."
},
"ACCOUNT": {
"CONFIRMATION_LABEL": "Confirmation du mot de passe"
},
"AREA": {
"TITLE": "Mon espace",
"HELLO": "Bonjour {{name}}",
"MANAGE_ACCOUNT": "Gérer mon compte",
"MANAGE_ACCOUNT_HELP": "Modifier mes informations, mon mot de passe, ou supprimer mon compte.",
"VIEW_SCHEDULE": "Voir un agenda",
"VIEW_SCHEDULE_HELP": "Consulter l'agenda d'un médecin et réserver un créneau.",
"MY_APPOINTMENT": "Mon rendez-vous",
"SEE_IN_SCHEDULE": "voir dans l'agenda",
"CANCEL_APPOINTMENT": "Annuler ce rendez-vous",
"NO_APPOINTMENT": "Vous n'avez aucun rendez-vous à venir."
},
"MY_ACCOUNT": {
"TITLE": "Gérer mon compte",
"NEW_PASSWORD_LABEL": "Nouveau mot de passe",
"CURRENT_PASSWORD_LABEL": "Mot de passe actuel",
"CURRENT_PASSWORD_HELP": "Obligatoire pour enregistrer une modification.",
"BACK": "Retour à mon espace",
"DELETE_TITLE": "Supprimer mon compte",
"DELETE_HELP": "Votre compte sera définitivement supprimé, ainsi que tous vos rendez-vous.",
"DELETE_CONFIRM": "Supprimer définitivement votre compte ? Votre rendez-vous éventuel sera annulé.",
"DELETE_SUBMIT": "Supprimer mon compte",
"UPDATED": "Votre compte a été modifié.",
"DELETED": "Votre compte a été supprimé."
},
"CONFIRMATION": {
"TITLE": "Confirmation",
"NO": "Non, revenir",
"YES": "Oui, confirmer"
}
}
|
| {
"APP": {
"TITLE": "RdvMedecins",
"LOGOUT": "Log out",
"MENU_SCHEDULE": "Schedule",
"MENU_DOCTORS": "Doctors",
"MENU_PATIENTS": "Patients",
"MENU_MY_AREA": "My area",
"LOADING": "Loading...",
"LANGUAGE": "Language"
},
"LOGIN": {
"TITLE": "Login",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Password",
"SUBMIT": "Log in",
"ERROR": "Incorrect login or password.",
"DEMO_ACCOUNTS": "Demo accounts (password = login):",
"DEMO_ADMIN": "ADMIN role: appointments + doctor and patient management",
"DEMO_DOCTOR": "DOCTOR role: booking and cancelling appointments",
"DEMO_USER": "USER role (patients): booking for themselves, managing their account",
"CREATE_ACCOUNT": "Create a patient account",
"CREATE_ACCOUNT_HELP": "To create an account, first type the characters shown in the image."
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Doctor",
"CHOOSE_DOCTOR": "-- choose a doctor --",
"DAY_LABEL": "Day",
"VIEW_SCHEDULE": "View schedule"
},
"SCHEDULE": {
"PAGE_TITLE": "Schedule",
"TITLE_PREFIX": "Schedule for",
"COLUMN_SLOT": "Slot",
"COLUMN_STATUS": "Status",
"FREE": "Free",
"BOOK": "Book",
"CANCEL_APPOINTMENT": "Cancel",
"CANCEL_CONFIRM": "Cancel this appointment?",
"EMPTY_STATE": "Choose a doctor and a day, then click \"View schedule\".",
"NO_SLOTS": "This doctor has no time slots.",
"BOOKED": "Appointment booked.",
"CANCELLED": "Appointment cancelled.",
"BOOKED_BY_OTHER": "Booked",
"ALREADY_BOOKED_INFO": "You already have an upcoming appointment: cancel it to book another one."
},
"BOOKING_DIALOG": {
"TITLE": "Book this slot",
"CLOSE_ARIA": "Close",
"SLOT": "Slot {{time}}",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choose a patient --",
"CANCEL": "Cancel",
"CONFIRM": "Confirm"
},
"PERSONS": {
"COLUMN_TITLE": "Title",
"COLUMN_FIRSTNAME": "First name",
"COLUMN_LASTNAME": "Last name",
"COLUMN_LOGIN": "Login",
"EDIT": "Edit",
"DELETE": "Delete",
"SAVE": "Save",
"BACK": "Back to the list",
"TITLE_LABEL": "Title",
"FIRSTNAME_LABEL": "First name",
"LASTNAME_LABEL": "Last name",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Password",
"LOGIN_HELP_CREATE": "Optional: defaults to the last name in lower case.",
"LOGIN_HELP_EDIT": "Leave empty to keep it unchanged.",
"PASSWORD_HELP_CREATE": "Optional: defaults to the login.",
"PASSWORD_HELP_EDIT": "Leave empty to keep it unchanged.",
"ACCOUNT_SECTION": "User account"
},
"DOCTORS": {
"TITLE": "Doctors",
"ADD": "Add a doctor",
"EDIT": "Edit a doctor",
"EMPTY": "No doctors.",
"DELETE_CONFIRM": "Delete this doctor, their time slots and their user account?",
"ADDED": "Doctor {{name}} has been added (login: {{login}}).",
"UPDATED": "Doctor {{name}} has been updated.",
"DELETED": "Doctor {{name}} has been deleted."
},
"CLIENTS": {
"TITLE": "Patients",
"ADD": "Add a patient",
"EDIT": "Edit a patient",
"EMPTY": "No patients.",
"DELETE_CONFIRM": "Delete this patient, their user account and all their appointments?",
"ADDED": "Patient {{name}} has been added (login: {{login}}).",
"UPDATED": "Patient {{name}} has been updated.",
"DELETED": "Patient {{name}} has been deleted."
},
"ERROR_PAGE": {
"TITLE": "Error",
"BACK": "Back to the home page"
},
"ERRORS": {
"LOGIN_TAKEN": "This login is already used by another account.",
"DOCTOR_ALREADY_EXISTS": "A doctor with this first and last name already exists.",
"PATIENT_ALREADY_EXISTS": "A patient with this first and last name already exists.",
"DOCTOR_HAS_APPOINTMENTS": "This doctor has appointments: cancel them before deleting the doctor.",
"SLOT_ALREADY_BOOKED": "This slot has just been booked by someone else.",
"CONCURRENT_UPDATE": "This record was changed by another user in the meantime. Go back to the list and reopen it before trying again.",
"DOCTOR_NOT_FOUND": "This doctor does not exist (any more).",
"PATIENT_NOT_FOUND": "This patient does not exist (any more).",
"SLOT_NOT_FOUND": "This slot does not exist (any more).",
"APPOINTMENT_NOT_FOUND": "This appointment does not exist (any more).",
"INVALID_DATE": "The requested date is not valid.",
"CHOOSE_PATIENT": "Choose a patient.",
"INVALID_FORM": "The form contains errors.",
"INVALID_TITLE": "Choose a title from the list.",
"FIRSTNAME_REQUIRED": "The first name is required.",
"FIRSTNAME_TOO_LONG": "The first name must not exceed 20 characters.",
"LASTNAME_REQUIRED": "The last name is required.",
"LASTNAME_TOO_LONG": "The last name must not exceed 20 characters.",
"INVALID_LOGIN": "At most 30 characters: unaccented lower-case letters, digits, dot, hyphen, underscore.",
"PASSWORD_TOO_LONG": "The password must not exceed 72 characters.",
"SESSION_EXPIRED": "Your session has expired: please log in again.",
"BAD_REQUEST": "The request is invalid.",
"FORBIDDEN": "Your role does not allow you to access this page.",
"NOT_FOUND": "This page does not exist.",
"SERVER_ERROR": "An unexpected error occurred. Please try again later.",
"TOO_MANY_ATTEMPTS": "Too many failed attempts. Try again in {{minutes}} minute(s).",
"WRONG_CAPTCHA": "The characters you typed do not match the image. A new image is shown.",
"TOO_MANY_ACCOUNTS": "Too many accounts have been created from your connection. Try again in {{minutes}} minute(s).",
"LOGIN_REQUIRED": "The login is required.",
"PASSWORD_REQUIRED": "The password is required.",
"PASSWORD_TOO_SHORT": "The password must be at least {{min}} characters long.",
"CONFIRMATION_REQUIRED": "Please confirm the password.",
"PASSWORDS_DIFFER": "The confirmation does not match the password.",
"CURRENT_PASSWORD_REQUIRED": "Enter your current password.",
"WRONG_CURRENT_PASSWORD": "Incorrect current password.",
"PAST_DATE": "Appointments cannot be booked for a past date.",
"PATIENT_HAS_UPCOMING_APPOINTMENT": "This patient already has an upcoming appointment: it must be cancelled before booking another one.",
"CAPTCHA_BEFORE_ACCOUNT": "To create an account, first type the characters shown in the image correctly, then click \"Create a patient account\".",
"AUTH_REQUIRED": "Please log in to access this page.",
"JSON_REQUIRED": "Request refused: the server expects JSON.",
"SERVER_UNREACHABLE": "The server does not respond. Please try again later."
},
"CAPTCHA": {
"LABEL": "Type the characters shown in the image",
"IMAGE_ALT": "Anti-robot verification image",
"NEW_IMAGE": "Another image",
"HELP": "Upper or lower case, it does not matter."
},
"REGISTRATION": {
"TITLE": "Create a patient account",
"INTRO": "With this account you can book your own appointments.",
"LOGIN_HELP": "Unaccented lower-case letters, digits, dot, hyphen, underscore.",
"PASSWORD_HELP": "At least {{min}} characters.",
"SUBMIT": "Create my account",
"BACK_TO_LOGIN": "Back to login",
"DONE": "Your account has been created. You can now log in with the login {{login}}."
},
"ACCOUNT": {
"CONFIRMATION_LABEL": "Confirm password"
},
"AREA": {
"TITLE": "My area",
"HELLO": "Hello {{name}}",
"MANAGE_ACCOUNT": "Manage my account",
"MANAGE_ACCOUNT_HELP": "Change my details or password, or delete my account.",
"VIEW_SCHEDULE": "View a schedule",
"VIEW_SCHEDULE_HELP": "See a doctor's schedule and book a slot.",
"MY_APPOINTMENT": "My appointment",
"SEE_IN_SCHEDULE": "see in the schedule",
"CANCEL_APPOINTMENT": "Cancel this appointment",
"NO_APPOINTMENT": "You have no upcoming appointment."
},
"MY_ACCOUNT": {
"TITLE": "Manage my account",
"NEW_PASSWORD_LABEL": "New password",
"CURRENT_PASSWORD_LABEL": "Current password",
"CURRENT_PASSWORD_HELP": "Required to save any change.",
"BACK": "Back to my area",
"DELETE_TITLE": "Delete my account",
"DELETE_HELP": "Your account will be permanently deleted, together with all your appointments.",
"DELETE_CONFIRM": "Permanently delete your account? Any appointment you have will be cancelled.",
"DELETE_SUBMIT": "Delete my account",
"UPDATED": "Your account has been updated.",
"DELETED": "Your account has been deleted."
},
"CONFIRMATION": {
"TITLE": "Confirmation",
"NO": "No, go back",
"YES": "Yes, confirm"
}
}
|
10.4.5. Die Services
10.4.5.1. src/app/services/session.service.ts
| // =========================================================================
// services/session.service.ts - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der angemeldete Benutzer (oder null) und das, was sich daraus ableitet (ist es der ADMIN?
// ein Patient?), in einem signalbasierten Root-Service (siehe Beispiel 20).
//
// Das JWT-Token selbst ist NICHT hier: Es liegt in einem httpOnly-Cookie, das
// nur der Browser verwaltet. Der Service behält nur die BESCHREIBUNG
// des Benutzers, die der Server zurückgibt ({ login, name, role }).
//
// Beim Start (und nach einem F5) ist der Service leer: check() fragt
// den Server, nur einmal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================
import { computed, inject, Injectable, signal } from '@angular/core';
import { RdvMedecinsApi } from '../api/rdvmedecins.api';
import { Role, User } from '../api/types';
@Injectable({ providedIn: 'root' })
export class SessionService {
private readonly api = inject(RdvMedecinsApi);
private readonly _user = signal<User | null>(null);
// wurde dem Server die Frage "Wer ist angemeldet?" schon gestellt?
private checking: Promise<void> | null = null;
readonly user = this._user.asReadonly();
readonly loggedIn = computed(() => this._user() !== null);
readonly role = computed<Role | null>(() => this._user()?.role ?? null);
readonly isAdmin = computed(() => this.role() === 'ADMIN');
readonly isPatient = computed(() => this.role() === 'USER');
// ADMIN und DOCTOR: Termine beliebiger Patienten buchen und stornieren
readonly isManager = computed(() => this.role() === 'ADMIN' || this.role() === 'DOCTOR');
// die Startseite jeder Rolle, direkt nach dem Login
readonly homePage = computed(() => (this.isPatient() ? '/my-area' : '/schedule'));
// wird vom Router-Guard vor JEDER Navigation aufgerufen; fragt den
// Server nur beim ersten Mal ab (das Promise wird aufbewahrt und wiederverwendet)
check(): Promise<void> {
this.checking ??= this.api
.me()
.then((u) => this._user.set(u))
.catch(() => this._user.set(null)); // 401: niemand; oder Server nicht erreichbar
return this.checking;
}
async logIn(login: string, password: string, captchaId: string, captcha: string): Promise<void> {
this._user.set(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._user.set(u);
}
async logOut(): Promise<void> {
try {
await this.api.logOut();
} finally {
this.forget();
}
}
// ohne den Server etwas zu fragen: Sitzung abgelaufen, Konto gelöscht
forget(): void {
this._user.set(null);
}
}
|
Der angemeldete Benutzer in einem Signal-Service (Beispiel 20):
- Zeile 22: der Zustand: der Benutzer oder [null]. Das Token selbst ist nicht hier: Es steckt in einem Cookie, den nur der Browser verarbeitet;
- Zeilen 26–32: was die Komponenten lesen: der Benutzer und das, was sich daraus ableiten lässt (ist der Benutzer angemeldet? ADMIN? ein Patient?);
- Zeile 35: die Startseite für jede Rolle;
- Zeilen 39–45: Beim Start (und nach einem F5) weiß der Service nicht, wer angemeldet ist: Er fragt den Server. [check] wird vom Router-Guard vor JEDER Navigation aufgerufen, fragt aber nur beim ersten Mal den Server ab: Das Promise wird aufbewahrt (Zeile 40, [??=]: „falls es noch nicht existiert“) und bei jedem weiteren Aufruf zurückgegeben. Folgen zwei Navigationen kurz aufeinander, warten sie auf dieselbe Antwort;
- Zeile 43: 401 (niemand) oder Server nicht erreichbar: kein Benutzer;
- Zeilen 56–62: Abmeldung; [finally]: Der Benutzer wird auch dann vergessen, wenn der Server nicht antwortet;
- Zeilen 65–67: den Benutzer vergessen, ohne eine Anfrage an den Server zu senden: Das tut der Interceptor bei einem 401.
10.4.5.2. src/app/services/messages.service.ts
| // =========================================================================
// services/messages.service.ts - die dem Benutzer angezeigten Meldungen
// -------------------------------------------------------------------------
// Gleiche Darstellung wie in der HTML-Anwendung:
// - ein ERFOLG wird OBEN auf der Seite angezeigt (grünes Banner);
// - ein FEHLER UNTEN, auf hellrosa Hintergrund ("sticky" Feld).
// 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 Seitenwechsel
// endet (Buchung, Hinzufügen eines Arztes...), hinterlässt ihre Meldung mit flash();
// sie wird auf der NÄCHSTEN Seite angezeigt und verschwindet bei der
// folgenden Navigation. Der Service weiß das, weil er auf die Router-Ereignisse hört
// (Ende jeder Navigation). Das war auf der Serverseite die Aufgabe des
// kurzlebigen Cookies "rdvmedecins_flash".
// =========================================================================
import { Injectable, inject, signal } from '@angular/core';
import { NavigationEnd, Router } from '@angular/router';
import { ApiError } from '../api/api-error';
export interface Message {
key: string;
params?: Record<string, string>;
}
@Injectable({ providedIn: 'root' })
export class MessagesService {
readonly success = signal<Message | null>(null);
readonly error = signal<Message | null>(null);
// die Meldungen, die auf der nächsten Seite angezeigt werden
private pending: { success: Message | null; error: Message | null } | null = null;
constructor() {
// eine neue Seite (auch wenn sich nur die Query ändert, /schedule?...):
// Die Meldungen der vorherigen Seite verschwinden, die Flash-Meldungen
// erscheinen. Ein Root-Service lebt so lange wie die Anwendung:
// kein Abbestellen nötig.
inject(Router).events.subscribe((e) => {
if (e instanceof NavigationEnd) {
this.newPage();
}
});
}
showSuccess(key: string, params?: Record<string, string>): void {
this.success.set({ key, params });
this.error.set(null);
}
showError(key: string, params?: Record<string, string>): void {
this.error.set({ key, params });
this.success.set(null);
}
// ein ApiError -> die Meldung der Seite; jeder andere Fehler ist eine
// Anomalie des Clients, die durchgereicht wird (Browser-Konsole)
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 die NÄCHSTE Seite
flash(type: 'success' | 'error', key: string, params?: Record<string, string>): void {
this.pending ??= { success: null, error: null };
this.pending[type] = { key, params };
}
private newPage(): void {
this.success.set(this.pending?.success ?? null);
this.error.set(this.pending?.error ?? null);
this.pending = null;
}
}
|
Dem Benutzer angezeigte Meldungen, wie in der HTML-Anwendung: eine Erfolgsmeldung am oberen Seitenrand, eine Fehlermeldung am unteren. Eine Meldung ist ein Übersetzungsschlüssel: Sie übersetzt sich automatisch, wenn der Benutzer die Sprache wechselt.
- Zeilen 29–30: die beiden Meldungen der aktuellen Seite;
- Zeilen 58–63: Ein [ApiError] wird zur Fehlermeldung der Seite; jeder andere Fehler ist ein clientseitiges Problem, das gemeldet werden darf;
- Zeilen 71–74: eine Flash-Meldung für die nächste Seite. Eine Aktion, die mit einem Seitenwechsel endet (ein Arzt wurde hinzugefügt, Rückkehr zur Liste), zeigt so ihre Meldung an;
- Zeilen 39–43: Der Service lauscht auf Router-Ereignisse (Beispiel 17). Am Ende jeder Navigation (Zeilen 76–80) verschwinden die Meldungen der vorherigen Seite, und die Flash-Meldungen erscheinen. Auf der Serverseite war dies die Aufgabe eines kurzlebigen Cookies.
10.4.5.3. src/app/services/confirmation.service.ts
| // =========================================================================
// services/confirmation.service.ts - "Are you sure?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 16: confirm(key) öffnet den Bestätigungsdialog
// (components/confirm-dialog.ts, einmal in App platziert) und liefert
// ein Promise, das mit true (Ja) oder false (Nein) aufgelöst wird. Die Meldung ist ein
// Übersetzungs-SCHLÜSSEL: Der Dialog übersetzt ihn in die aktuelle Sprache.
//
// if (await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM')) { ... }
// =========================================================================
import { inject, Injectable, signal } from '@angular/core';
import { MessagesService } from './messages.service';
@Injectable({ providedIn: 'root' })
export class ConfirmationService {
private readonly messages = inject(MessagesService);
private readonly _messageKey = signal<string | null>(null); // null: Dialog geschlossen
readonly messageKey = this._messageKey.asReadonly();
private answer: ((yes: boolean) => void) | null = null;
confirm(key: string): Promise<boolean> {
this.answer?.(false); // eine noch offene Frage? Sie zählt als "Nein"
// eine neue Frage: die Meldungen der vorherigen Aktion sind veraltet
this.messages.clear();
this._messageKey.set(key);
return new Promise<boolean>((resolve) => {
this.answer = resolve;
});
}
respond(yes: boolean): void {
this._messageKey.set(null);
const r = this.answer;
this.answer = null;
r?.(yes);
}
}
|
Der Service aus Beispiel 16. Die Meldung ist nun ein Übersetzungsschlüssel (Zeile 18), und eine neue Frage löscht die Meldungen der vorherigen Aktion (Zeile 25).
| // =========================================================================
// services/form-submission.ts - ein Formular an den Server senden
// -------------------------------------------------------------------------
// Alle Formulare der Anwendung folgen demselben Muster wie
// Beispiel 25: Keine Regel wird im Browser geprüft (sie
// liegen an EINER einzigen Stelle, dem Server), und bei einer Ablehnung:
// - wird der Fehler jedes Felds (ApiError.fields) an das Feld des
// Signal-Formulars gehängt, das es rot umrandet anzeigt;
// - wird die allgemeine Meldung (ApiError.key) unten auf der Seite angezeigt.
// Diese Klasse fasst diese Schritte zusammen. Eine Seite erstellt eine pro Formular:
//
// protected readonly submission = new FormSubmission(this.f);
// if (await this.submission.submit(() => this.api.register(this.model()))) { ... }
//
// Sie wird in einem Injektionskontext verwendet (Initialisierung eines Felds
// der Komponentenklasse): Dort holt sie sich den Messages-Service.
// =========================================================================
import { inject, signal } from '@angular/core';
import { FieldTree, isFieldTree, submit, ValidationError } from '@angular/forms/signals';
import { ApiError } from '../api/api-error';
import { MessagesService } from './messages.service';
export class FormSubmission<T> {
private readonly messages = inject(MessagesService);
// die Parameter der Fehlermeldungen ({min}...), vom Server zurückgegeben
readonly params = signal<Record<string, string>>({});
constructor(private readonly form: FieldTree<T>) {}
// führt das Absenden aus; gibt true zurück, wenn es erfolgreich war. Bei einem ApiError werden die
// Fehler angezeigt und false wird zurückgegeben.
// ignoreValidators: auch absenden, wenn die Regeln des Formularschemas
// (falls vorhanden) nicht erfüllt sind
async submit(action: () => Promise<unknown>, ignoreValidators = false): Promise<boolean> {
this.params.set({});
let succeeded = false;
await submit(this.form, {
ignoreValidators: ignoreValidators ? 'all' : 'pending',
action: async () => {
try {
await action();
succeeded = true;
return null; // kein Fehler
} catch (e) {
this.messages.showApiError(e); // (wirft jeden Fehler erneut, der kein ApiError ist)
const error = e as ApiError;
this.params.set(error.params);
return this.fieldErrors(error);
}
},
});
return succeeded;
}
// { lastName: 'ERRORS.LASTNAME_REQUIRED' } -> ein Fehler, der dem Feld f.lastName zugeordnet wird
private fieldErrors(e: ApiError): ValidationError.WithOptionalFieldTree[] {
const fields = this.form as unknown as Record<string, unknown>;
return Object.entries(e.fields)
.filter(([name]) => isFieldTree(fields[name]))
.map(([name, key]) => ({ kind: 'server', message: key, fieldTree: fields[name] as FieldTree<unknown> }));
}
}
|
Alle Formulare der Anwendung folgen dem in Beispiel 25 gezeigten Muster: Die Regeln werden vom Server validiert, und wird ein Formular abgelehnt, wird der Fehler zu jedem Feld unterhalb dieses Feldes angezeigt, mit einer allgemeinen Fehlermeldung am unteren Seitenrand. Diese Klasse fasst diese Aktionen zusammen, damit sie nicht auf jeder Seite wiederholt werden müssen:
- Zeile 24: eine generische Klasse: [T] ist der Typ des Formularmodells;
- Zeile 25: [inject] in einer Feldinitialisierung: Die Klasse muss in einem Injektionskontext erzeugt werden, das heißt während der Initialisierung eines Komponentenfeldes (Zeile 12);
- Zeile 27: die Parameter für Fehlermeldungen ([{{min}}] ...), die vom Server zurückgegeben werden;
- Zeilen 35–54: das Absenden. [submit] (Beispiel 25) führt die Aktion aus; die Methode gibt [true] zurück, wenn die Aktion erfolgreich war;
- Zeile 39: [ignoreValidators]: Standardmäßig (['pending']) führt [submit] die Aktion nicht aus, wenn das Formular Validierungsfehler hat (die Anmeldeseite hat ein Schema mit zwei Pflichtfeldern). ['all']: sendet die Anfrage dennoch (siehe die Anmeldeseite);
- Zeile 46: die allgemeine Meldung;
- Zeilen 57–62: Feldfehler. [isFieldTree] prüft, ob das Formular tatsächlich ein Feld mit diesem Namen hat: Der Server kann einen Fehler für ein Feld melden, das das Formular nicht anzeigt.
| // =========================================================================
// pipes/formatting.ts - die Anzeige von Personen, Uhrzeiten und Tagen
// -------------------------------------------------------------------------
// Der Server sendet ROHDATEN (startHour: 8, startMinute: 0; day:
// "2026-10-05"); die Formatierung, die von der Sprache abhängt, ist Sache
// des Clients. Funktionen, die vom Code verwendet werden, und Pipes (Datei
// formatting.pipes.ts), die von den Templates verwendet werden.
// =========================================================================
import { Slot, Identity } from '../api/types';
// "Mme Alice DURAND"
export function label(p: Identity): string {
return `${p.title} ${p.firstName} ${p.lastName}`;
}
// "8:05" statt "8:5"
export function time(h: number, m: number): string {
return `${h}:${String(m).padStart(2, '0')}`;
}
// "8:00 - 8:20"
export function timeRange(s: Slot): string {
return `${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}`;
}
// heutiges Datum im Format "yyyy-MM-dd" (das von <input type="date"> und von der API)
export function today(): string {
const d = new Date();
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}
// true, wenn [day] ein existierendes Datum im Format yyyy-MM-dd ist
export function isValidDate(day: unknown): day is string {
if (typeof day !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(day)) {
return false;
}
const date = new Date(`${day}T00:00:00Z`);
return !isNaN(date.getTime()) && date.toISOString().slice(0, 10) === day;
}
// "lundi 5 octobre 2026" / "Monday 5 October 2026"
export function longDate(day: string, language: string | null): string {
return new Intl.DateTimeFormat(language === 'en' ? 'en-GB' : 'fr-FR', {
dateStyle: 'full',
timeZone: 'UTC', // "2026-10-05T00:00:00Z" muss der 5. bleiben, unabhängig von der Zeitzone
}).format(new Date(`${day}T00:00:00Z`));
}
|
Der Server sendet Rohdaten ([startHour: 8, startMinute: 0]; [day: "2026-10-05"]); die Formatierung, die von der Sprache abhängt, liegt in der Verantwortung des Clients:
- Zeilen 34–40: Ist dies ein gültiges Datum? [2026-02-30] hat das richtige Format, existiert aber nicht: [new Date] würde es in den 2. März umwandeln. Wir prüfen daher, ob es identisch zurückgelesen wird. [day is string]: Wenn die Funktion true zurückgibt, weiß [TypeScript], dass [day] ein String ist;
- Zeilen 43–48: [Intl.DateTimeFormat], vom Browser bereitgestellt, schreibt das Datum in der gewünschten Sprache. Die Zeitzone UTC verhindert, dass ein Browser westlich von Greenwich den Vortag anzeigt.
| // =========================================================================
// pipes/formatting.pipes.ts - die Funktionen aus formatting.ts als Pipes
// -------------------------------------------------------------------------
// {{ doctor | label }} "Mme Marie PELISSIER"
// {{ slot | timeRange }} "8:00 - 8:20"
// {{ day | longDate: language() }} "Monday 5 October 2026"
// longDate erhält die Sprache als Parameter: eine reine Pipe wird nur neu berechnet,
// wenn sich eines ihrer Argumente ändert - ein Sprachwechsel löst also die Neuberechnung aus.
// =========================================================================
import { Pipe, PipeTransform } from '@angular/core';
import { Slot, Identity } from '../api/types';
import { timeRange, longDate, label } from './formatting';
@Pipe({ name: 'label' })
export class LabelPipe implements PipeTransform {
transform(p: Identity): string {
return label(p);
}
}
@Pipe({ name: 'timeRange' })
export class TimeRangePipe implements PipeTransform {
transform(s: Slot): string {
return timeRange(s);
}
}
@Pipe({ name: 'longDate' })
export class LongDatePipe implements PipeTransform {
transform(day: string, language: string | null): string {
return longDate(day, language);
}
}
|
Dieselben Funktionen als Pipes für Templates. [longDate] erhält die Sprache als Parameter: Eine reine Pipe (Beispiel 09) wird nur neu berechnet, wenn sich eines ihrer Argumente ändert; ein Sprachwechsel löst daher eine Neuberechnung aus.
10.4.7. Der Router
10.4.7.1. src/app/app.routes.ts
| // =========================================================================
// app.routes.ts - die Seiten der Anwendung und ihre Zugriffsrechte
// -------------------------------------------------------------------------
// Die GLEICHEN Adressen wie in der HTML-Anwendung (/login, /schedule, /doctors,
// /my-area...), aber nun sind es Routen des CLIENTS. Der
// Browser sendet nur für die allererste Seite eine Anfrage an den Server;
// danach ändert der Router die Adresse und die angezeigte Komponente.
//
// Die Kehrseite: Lädt der Benutzer /schedule neu (F5), fordert der
// Browser /schedule tatsächlich vom Server an, der dann index.html
// zurückgeben muss (ng serve erledigt das in der Entwicklung; in der Produktion
// siehe web/client-spa.ts des JSON-Servers).
//
// Alle Seiten sind KINDER einer Route ohne Komponente,
// die den Guard sessionGuard (canActivateChild) trägt: Er gilt somit für
// jede von ihnen. Jede Route deklariert:
// - title: Übersetzungsschlüssel des Tab-Titels (siehe i18n/title.strategy.ts);
// - data : public (ohne Anmeldung zugänglich), roles (die
// erlaubten Rollen), type ('doctors' oder 'clients'), code (403, 404).
// Dank withComponentInputBinding (app.config.ts) kommen die Parameter von
// der Adresse (:id, ?day=...) UND die data (type, code) in den
// INPUTS der Seitenkomponenten an.
// =========================================================================
import { Routes } from '@angular/router';
import { PersonType } from './api/rdvmedecins.api';
import { Role } from './api/types';
import { registrationGuard, sessionGuard, numericId } from './guards';
import { LoginPage } from './pages/login/login';
import { SchedulePage } from './pages/schedule/schedule';
// die Routen zur Verwaltung der Ärzte UND der Clients (ADMIN) nach dem
// gleichen Muster; die Seiten werden bei Bedarf geladen (loadComponent)
function personRoutes(type: PersonType, title: string, addTitle: string, editTitle: string): Routes {
const data = { roles: ['ADMIN'] as Role[], type };
return [
{ path: type, loadComponent: () => import('./pages/persons/persons'), title: title, data },
{ path: `${type}/add`, loadComponent: () => import('./pages/person-form/person-form'), title: addTitle, data },
{
path: `${type}/:id/edit`,
canMatch: [numericId],
loadComponent: () => import('./pages/person-form/person-form'),
title: editTitle,
data,
},
];
}
export const routes: Routes = [
{
path: '',
canActivateChild: [sessionGuard],
children: [
// "/": weiter zu /login, das bei bestehender Anmeldung selbst zur Startseite der Rolle weiterleitet
{ path: '', pathMatch: 'full', redirectTo: 'login' },
{ path: 'login', component: LoginPage, title: 'LOGIN.TITLE', data: { public: true } },
{ path: 'schedule', component: SchedulePage, title: 'SCHEDULE.PAGE_TITLE' },
...personRoutes('doctors', 'DOCTORS.TITLE', 'DOCTORS.ADD', 'DOCTORS.EDIT'),
...personRoutes('clients', 'CLIENTS.TITLE', 'CLIENTS.ADD', 'CLIENTS.EDIT'),
{
path: 'register',
loadComponent: () => import('./pages/register/register'),
title: 'REGISTRATION.TITLE',
data: { public: true },
canActivate: [registrationGuard],
},
{
path: 'my-area',
loadComponent: () => import('./pages/patient-area/patient-area'),
title: 'AREA.TITLE',
data: { roles: ['USER'] },
},
{
path: 'my-account',
loadComponent: () => import('./pages/my-account/my-account'),
title: 'MY_ACCOUNT.TITLE',
data: { roles: ['USER'] },
},
{ path: 'forbidden', loadComponent: () => import('./pages/error/error'), title: 'ERROR_PAGE.TITLE', data: { code: 403 } },
{
path: '**',
loadComponent: () => import('./pages/error/error'),
title: 'ERROR_PAGE.TITLE',
data: { code: 404, public: true },
},
],
},
];
|
Dieselben URLs wie in der HTML-Anwendung (/login, /schedule, /doctors, /my-area ...), aber es sind nun Client-Routen:
- Zeilen 50–53: Alle Seiten sind Kinder ([children]) einer Route ohne Komponente, die den Guard [sessionGuard] trägt: [canActivateChild] wendet ihn auf jede von ihnen an, ohne dass er wiederholt werden muss;
- Zeile 55: Die Adresse / führt zur Anmeldeseite, die ihrerseits zur Startseite der Rolle weiterleitet, wenn der Benutzer angemeldet ist;
- Zeilen 56–57: Die beiden am häufigsten besuchten Seiten gehören zur Hauptdatei; die anderen werden bei Bedarf geladen ([loadComponent]);
- [title]: der Übersetzungsschlüssel für den Titel des Tabs;
- [data]: [public] (ohne Anmeldung zugänglich), [roles] (autorisierte Rollen; fehlt der Eintrag: alle angemeldeten Rollen), [type] (['doctors'] oder ['clients']), [code] (403, 404). Dank [withComponentInputBinding] werden die Routendaten auch an die Inputs der Seitenkomponente übergeben, ebenso wie die Adressparameter;
- Zeilen 34–47: Die drei Routen für die Arztverwaltung und die der Kundenverwaltung werden von derselben Funktion erzeugt: Beide Verwaltungen verwenden dieselben Seiten, mit einem anderen [type];
- Zeile 41: [canMatch]: ein Guard, der bestimmt, ob die Route zur Adresse passt. Schlägt er fehl, probiert der Router die folgenden Routen: /doctors/abc/edit führt somit zu einer 404-Seite;
- Zeile 65: ein Guard speziell für die Seite zur Kontoerstellung;
- Zeile 79: die 403-Seite, auf die der Guard umleitet;
- Zeilen 80–85: jede andere Adresse: die 404-Seite.
10.4.7.2. src/app/guards.ts
| // =========================================================================
// guards.ts - die Guards des Routers
// -------------------------------------------------------------------------
// sessionGuard: der Guard ALLER Seiten (siehe app.routes.ts). Vor
// jeder Navigation:
// 1. beim ersten Mal (Start, F5) fragt er den Server, wer
// angemeldet ist (SessionService.check);
// 2. er prüft die in den data der Route beschriebenen Rechte:
// - public: ohne Anmeldung zugänglich;
// - roles : die erlaubten Rollen (fehlt der Eintrag = alle angemeldeten Rollen).
//
// ZUR ERINNERUNG: Diese Prüfungen sind nur eine ERLEICHTERUNG (keine nutzlose
// Seite anzeigen). Der Schutz der Daten wird vom Server gewährleistet, der
// bei JEDER Anfrage Token und Rolle erneut prüft.
//
// WARNUNG: inject() ist nur am ANFANG eines Guards erlaubt, vor jedem
// await (danach geht der "injection context" verloren).
// =========================================================================
import { inject } from '@angular/core';
import { CanActivateChildFn, CanActivateFn, CanMatchFn, Router } from '@angular/router';
import { Role } from './api/types';
import { RdvMedecinsApi } from './api/rdvmedecins.api';
import { SessionService } from './services/session.service';
import { MessagesService } from './services/messages.service';
export const sessionGuard: CanActivateChildFn = async (route, state) => {
const session = inject(SessionService);
const router = inject(Router);
await session.check();
if (route.data['public']) {
// bereits angemeldet: die Anmeldeseite ergibt keinen Sinn mehr
if (route.routeConfig?.path === 'login' && session.loggedIn()) {
return router.parseUrl(session.homePage());
}
return true;
}
if (!session.loggedIn()) {
// die angeforderte Seite wird gemerkt, um nach der Anmeldung dorthin zurückzukehren
return router.createUrlTree(['/login'], { queryParams: { redirect: state.url } });
}
const roles = route.data['roles'] as Role[] | undefined;
if (roles && !roles.includes(session.role()!)) {
return router.createUrlTree(['/forbidden']);
}
return true;
};
// ein Guard, der SPEZIFISCH für die Route /register gilt: ohne Pass (auf der Anmeldeseite
// gelöstes CAPTCHA) zurück zur Anmeldeseite
export const registrationGuard: CanActivateFn = async () => {
const api = inject(RdvMedecinsApi);
const messages = inject(MessagesService);
const router = inject(Router);
const { valid } = await api.registrationAccessStatus().catch(() => ({ valid: false }));
if (!valid) {
messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
return router.createUrlTree(['/login']);
}
return true;
};
// /doctors/3/edit: die Route PASST nur, wenn das 2. Segment der
// Adresse eine Zahl ist (/doctors/abc/edit führt zur 404-Seite)
export const numericId: CanMatchFn = (_route, segments) => /^\d+$/.test(segments[1]?.path ?? '');
|
- Zeile 27: Ein Guard kann [async] sein: Der Router wartet auf seine Antwort;
- Zeilen 28–30: ACHTUNG: [inject] ist nur am Anfang des Guards erlaubt, vor jedem [await]; danach geht der Injektionskontext verloren;
- Zeile 30: Beim ersten Mal wird der Server gefragt, wer angemeldet ist;
- Zeilen 32–38: eine öffentliche Seite; aber die Anmeldeseite ergibt für einen angemeldeten Benutzer keinen Sinn mehr (Zeile 34). [parseUrl] wandelt eine Adresse in einen [UrlTree]um, den Wert, der eine Umleitung auslöst;
- Zeilen 39–42: nicht angemeldet: zur Anmeldeseite, wobei die angeforderte Seite beibehalten wird;
- Zeilen 43–46: ungültige Rolle: Umleitung auf die 403-Seite;
- Zeilen 52–62: Zum Erstellen eines Kontos ist ein „Pass“ erforderlich, den man durch Lösen des CAPTCHA auf der Anmeldeseite erhält. Ohne ihn wird der Benutzer mit einer Meldung zur Anmeldeseite zurückgeschickt;
- Zeile 66: Der Guard [canMatch] erhält die Segmente der Adresse: [['doctors', '3', 'edit']].
Diese Guards sind lediglich eine Annehmlichkeit: Der Schutz der Daten wird vom Server gewährleistet, der bei jeder Anfrage Token und Rolle erneut prüft.
10.4.8. Die Komponenten
10.4.8.1. src/app/components/nav-bar
| // =========================================================================
// components/nav-bar/nav-bar.ts - die Navigationsleiste
// -------------------------------------------------------------------------
// Gleicher Inhalt wie in der HTML-Anwendung (views/partials/navbar.hbs):
// Titel, Menüs je nach Rolle, FR / EN, Rolle, Name, Abmelden.
// "Doctors" und "Patients" erscheinen nur für den ADMIN: eine reine Anzeige-
// erleichterung, der eigentliche Schutz liegt beim Server.
// =========================================================================
import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { SessionService } from '../../services/session.service';
import { LanguageService } from '../../i18n/language.service';
import { LANGUAGES } from '../../i18n/i18n';
@Component({
selector: 'app-nav-bar',
imports: [RouterLink, RouterLinkActive, TranslatePipe],
templateUrl: './nav-bar.html',
})
export class NavBar {
protected readonly session = inject(SessionService);
protected readonly languages = inject(LanguageService);
protected readonly LANGUAGES = LANGUAGES;
private readonly router = inject(Router);
protected async logOut(): Promise<void> {
await this.session.logOut().catch(() => {}); // auch wenn der Server nicht antwortet
this.router.navigate(['/login']);
}
}
|
- Zeile 29: Meldet ab, auch wenn der Server nicht antwortet; kehrt dann zur Anmeldeseite zurück.
| <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>
@if (session.loggedIn()) {
<ul class="navbar-nav me-auto">
@if (session.isPatient()) {
<li class="nav-item">
<!-- routerLinkActive: die Bootstrap-Klasse des Menüs der angezeigten Seite -->
<a class="nav-link" routerLink="/my-area" routerLinkActive="active">{{ 'APP.MENU_MY_AREA' | translate }}</a>
</li>
}
<li class="nav-item">
<a class="nav-link" routerLink="/schedule" routerLinkActive="active">{{ 'APP.MENU_SCHEDULE' | translate }}</a>
</li>
@if (session.isAdmin()) {
<li class="nav-item">
<a class="nav-link" routerLink="/doctors" routerLinkActive="active">{{ 'APP.MENU_DOCTORS' | translate }}</a>
</li>
<li class="nav-item">
<a class="nav-link" routerLink="/clients" routerLinkActive="active">{{ 'APP.MENU_PATIENTS' | translate }}</a>
</li>
}
</ul>
} @else {
<div class="me-auto"></div>
}
<div class="d-flex align-items-center gap-2">
<!-- FR / EN: keine Anfrage an den Server, die Seite wird an Ort und Stelle neu übersetzt -->
<div class="btn-group btn-group-sm" role="group" [attr.aria-label]="'APP.LANGUAGE' | translate">
@for (l of LANGUAGES; track l) {
<button type="button" class="btn" [class]="languages.language() === l ? 'btn-light' : 'btn-outline-light'"
[attr.aria-pressed]="languages.language() === l" (click)="languages.change(l)">
{{ l.toUpperCase() }}
</button>
}
</div>
@if (session.user(); as u) {
<span class="badge text-bg-light text-primary">{{ u.role }}</span>
<span class="text-white">{{ u.name }}</span>
<button type="button" class="btn btn-sm btn-outline-light" (click)="logOut()">{{ 'APP.LOGOUT' | translate }}</button>
}
</div>
</nav>
|
- Zeilen 4–23: die Menüs, abhängig von der Rolle;
- Zeilen 31–36: die Schaltflächen FR / EN; [aria-pressed] zeigt Screenreadern an, welche Schaltfläche gedrückt ist;
- Zeilen 39–43: Rolle, Name, Abmeldung.
10.4.8.2. src/app/components/success-message.ts und error-panel.ts
| // =========================================================================
// components/success-message.ts - die ERFOLGSMELDUNG am Seitenanfang
// (Termin gebucht, Arzt hinzugefügt...) - siehe services/messages.service.ts.
// role="status": ein Screenreader kündigt sie an, ohne den Benutzer zu unterbrechen.
// =========================================================================
import { Component, inject } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { MessagesService } from '../services/messages.service';
@Component({
selector: 'app-success-message',
imports: [TranslatePipe],
template: `
@if (messages.success(); as m) {
<div class="alert alert-success" role="status">{{ m.key | translate: m.params }}</div>
}
`,
})
export class SuccessMessage {
protected readonly messages = inject(MessagesService);
}
|
| // =========================================================================
// components/error-panel.ts - das Fehlerpanel am ENDE jeder Seite, auf
// hellrosa Hintergrund (Klasse .error-panel, siehe styles.css) - wie
// views/partials/errors.hbs der HTML-Anwendung.
// role="alert": ein Screenreader kündigt die Meldung an, sobald sie erscheint.
// =========================================================================
import { Component, inject } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { MessagesService } from '../services/messages.service';
@Component({
selector: 'app-error-panel',
imports: [TranslatePipe],
template: `
@if (messages.error(); as m) {
<div class="error-panel" role="alert">{{ m.key | translate: m.params }}</div>
}
`,
})
export class ErrorPanel {
protected readonly messages = inject(MessagesService);
}
|
Zwei kleine Komponenten, die die Meldungen des Services [MessagesService] anzeigen, samt ihren Parametern übersetzt. Die Rollen [status] und [alert] veranlassen Screenreader, die Meldungen anzukündigen.
10.4.8.3. src/app/components/confirm-dialog
| // =========================================================================
// components/confirm-dialog/confirm-dialog.ts
// -------------------------------------------------------------------------
// Der Dialog "Are you sure?" aus Beispiel 16, für die Tastatur ergänzt,
// wie public/js/app.js der HTML-Anwendung:
// - beim Öffnen springt der Fokus auf "No, go back": ein unbedachter Druck auf
// die Eingabetaste löscht nichts;
// - Escape schließt den Dialog (= Nein);
// - Tab und Umschalt+Tab bleiben INNERHALB des Dialogs (sonst würde der Fokus
// auf die ausgegraute Seite dahinter wandern);
// - beim Schließen kehrt der Fokus zu dem Element zurück, das ihn hatte (zum
// Beispiel der angeklickte Button "Delete").
// "No, go back" statt "Cancel": Die Frage lautet manchmal "Cancel this
// appointment?", und ein Button "Cancel" wäre dort mehrdeutig.
// =========================================================================
import { Component, effect, ElementRef, inject, untracked, viewChild } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { ConfirmationService } from '../../services/confirmation.service';
@Component({
selector: 'app-confirm-dialog',
imports: [TranslatePipe],
templateUrl: './confirm-dialog.html',
})
export class ConfirmDialog {
protected readonly confirmation = inject(ConfirmationService);
private readonly dialog = viewChild<ElementRef<HTMLElement>>('dialog');
private readonly noButton = viewChild<ElementRef<HTMLButtonElement>>('noButton');
private previousFocus: HTMLElement | null = null;
constructor() {
// der Dialog öffnet sich (der Button "No" erscheint) oder schließt sich
effect(() => {
const button = this.noButton();
untracked(() => {
if (button) {
this.previousFocus = document.activeElement as HTMLElement | null;
button.nativeElement.focus();
} else {
this.previousFocus?.focus();
this.previousFocus = null;
}
});
});
}
protected onKeydown(e: KeyboardEvent): void {
const dialog = this.dialog()?.nativeElement;
if (e.key === 'Escape') {
this.confirmation.respond(false);
} else if (e.key === 'Tab' && dialog) {
const buttons = [...dialog.querySelectorAll<HTMLButtonElement>('button')];
const first = buttons[0];
const last = buttons[buttons.length - 1];
if (e.shiftKey && document.activeElement === first) {
e.preventDefault();
last?.focus();
} else if (!e.shiftKey && document.activeElement === last) {
e.preventDefault();
first?.focus();
}
}
}
// ein Klick auf den ausgegrauten Hintergrund (und nicht in den Dialog selbst) = Nein
protected onBackdropClick(e: MouseEvent): void {
if (e.target === e.currentTarget) {
this.confirmation.respond(false);
}
}
}
|
Das Fenster aus Beispiel 16, ergänzt um Tastaturunterstützung:
- Zeilen 34–45: ein Effect, der das Erscheinen und Verschwinden der Schaltfläche „Nein“ verfolgt. Beim Öffnen wird das Element, das den Fokus hatte, gemerkt, und der Fokus wird auf die Schaltfläche „Nein“ gesetzt; beim Schließen kehrt der Fokus zum gemerkten Element zurück (zum Beispiel zur angeklickten Schaltfläche „Löschen“). [untracked]: Die in dieser Funktion gelesenen Signale werden nicht zu Abhängigkeiten des Effects;
- Zeilen 48–64: die Tastatur. Esc antwortet mit „Nein“; Tab und Shift+Tab bleiben innerhalb des Fensters: Von der letzten Schaltfläche gelangt man zur ersten zurück und umgekehrt. Andernfalls würde der Fokus auf die ausgegraute Seite dahinter wandern;
- Zeilen 67–71: Ein Klick auf den ausgegrauten Hintergrund antwortet mit „Nein“.
| @if (confirmation.messageKey(); as key) {
<div (keydown)="onKeydown($event)">
<div class="modal-backdrop fade show"></div>
<div #dialog class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true"
aria-labelledby="confirmation-title" aria-describedby="confirmation-message" (click)="onBackdropClick($event)">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 id="confirmation-title" class="modal-title">{{ 'CONFIRMATION.TITLE' | translate }}</h5>
<button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate"
(click)="confirmation.respond(false)"></button>
</div>
<div class="modal-body">
<p id="confirmation-message" class="mb-0">{{ key | translate }}</p>
</div>
<div class="modal-footer">
<button #noButton type="button" class="btn btn-secondary" (click)="confirmation.respond(false)">
{{ 'CONFIRMATION.NO' | translate }}
</button>
<button type="button" class="btn btn-danger" (click)="confirmation.respond(true)">{{ 'CONFIRMATION.YES' | translate }}</button>
</div>
</div>
</div>
</div>
</div>
}
|
- Zeile 2: Tastenanschläge werden auf dem Element abgehört, das das Fenster enthält;
- Zeile 14: die Meldung, ein übersetzter Schlüssel.
| // =========================================================================
// components/input-field.ts - ein vollständiges Formularfeld
// -------------------------------------------------------------------------
// Label + Feld + Hilfemeldung ODER Fehlermeldung. Alle
// Formulare der Anwendung verwenden es, mit einem Signal-Formular:
//
// <app-input-field [formField]="f.lastName" fieldId="lastName" label="PERSONS.LASTNAME_LABEL" [maxChars]="20" />
//
// Es ist ein SELBSTGEBAUTES FORMULAR-STEUERELEMENT: Durch die Implementierung des Interface
// FormValueControl akzeptiert es [formField] wie ein gewöhnliches <input>.
// Der Vertrag ist einfach:
// - value (ein model()): der Wert des Feldes, vom Formular gelesen UND
// geschrieben;
// - errors (ein optionaler Input des Vertrags): Deklariert die Komponente ihn,
// legt die Direktive [formField] die Fehler des Feldes darin ab -
// hier die vom SERVER zurückgegebenen (siehe pages/person-form.ts).
// label, help und die Fehlermeldung sind Übersetzungs-SCHLÜSSEL.
// =========================================================================
import { booleanAttribute, Component, computed, input, model } from '@angular/core';
import { FormValueControl, ValidationError } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
@Component({
selector: 'app-input-field',
imports: [TranslatePipe],
// eine Komponente wird standardmäßig "inline" dargestellt: Wir machen sie zu einem Block,
// damit die vom Elternelement gesetzten Klassen (mb-3, col-sm-6) greifen
styles: `
:host {
display: block;
}
`,
template: `
<label class="form-label" [for]="fieldId()">{{ label() | translate }}</label>
<input class="form-control" [id]="fieldId()" [type]="type()" [value]="value()" (input)="onInput($event)"
[class.is-invalid]="error()" [attr.maxlength]="maxChars() ?? null" [autocomplete]="autocomplete()"
[required]="mandatory()" [attr.aria-invalid]="error() ? 'true' : null" [attr.aria-describedby]="fieldId() + '-message'">
@if (error(); as e) {
<div class="invalid-feedback" [id]="fieldId() + '-message'">{{ e | translate: params() }}</div>
} @else if (help(); as h) {
<div class="form-text" [id]="fieldId() + '-message'">{{ h | translate: params() }}</div>
}
`,
})
export class InputField implements FormValueControl<string> {
// der Vertrag FormValueControl
readonly value = model('');
readonly errors = input<readonly ValidationError.WithOptionalFieldTree[]>([]);
// unsere eigenen Inputs
// die id des <input> (nicht "id": Ein id-Attribut bliebe AUCH auf
// <app-input-field> bestehen, und die Seite hätte zwei Elemente mit derselben id)
readonly fieldId = input.required<string>();
readonly label = input.required<string>(); // Übersetzungsschlüssel
readonly type = input<'text' | 'password'>('text');
readonly help = input<string>(); // Schlüssel der Hilfemeldung
readonly params = input<Record<string, string>>({}); // Parameter der Meldungen ({min}...)
readonly maxChars = input<number>();
readonly autocomplete = input('off');
readonly mandatory = input(false, { transform: booleanAttribute });
// der erste Fehler des Feldes (sein Übersetzungsschlüssel), falls vorhanden
protected readonly error = computed(() => this.errors()[0]?.message);
protected onInput(event: Event): void {
this.value.set((event.target as HTMLInputElement).value);
}
}
|
Ein vollständiges Formularfeld: Label, Feld, Tooltip oder Fehlermeldung. Alle Formulare der Anwendung verwenden es. Es ist ein benutzerdefiniertes Formularsteuerelement: Durch die Einhaltung des Vertrags [FormValueControl] akzeptiert es die Direktive [[formField]] wie ein gewöhnliches [<input>]:
- Zeile 46: Die Klasse implementiert das Interface [FormValueControl<string>]: Der Compiler prüft, ob sie den Vertrag einhält;
- Zeile 48: [value], ein [model()] (Beispiel 11): der Wert des Feldes, den die Direktive [[formField]] liest UND schreibt;
- Zeile 49: [errors], ein optionaler Input des Vertrags: Wenn die Komponente ihn deklariert, legt die Direktive dort die Fehler des Feldes ab;
- Zeilen 54–61: komponentenspezifische Inputs. Der Bezeichner für das Element [<input>] heißt [fieldId], nicht [id]: Ein Attribut [id] , das auf [<app-input-field>] gesetzt wird, würde auch auf diesem Element gesetzt bleiben, und die Seite hätte zwei Elemente mit demselben Bezeichner;
- Zeile 61: [booleanAttribute] wandelt das Vorhandensein des Attributs ([mandatory], ohne Wert) in [true] um;
- Zeile 64: der erste Fehler des Feldes: sein Übersetzungsschlüssel;
- Zeilen 36–38: Das Element [<input>] zeigt den Wert an und gibt ihn bei jedem Tastenanschlag zurück (Zeilen 66–68). [aria-invalid] und [aria-describedby] verknüpfen das Feld für Screenreader mit seiner Meldung;
- Zeilen 39–43: die Fehlermeldung oder andernfalls die Hilfemeldung, samt ihren Parametern übersetzt;
- Zeilen 29–33: [:host] bezeichnet das Komponentenelement selbst ([<app-input-field>]). Ein dem Browser unbekanntes Element wird „inline“ dargestellt: Es wird in einen Block umgewandelt, damit die vom übergeordneten Element angewendeten Klassen ([col-sm-6]) wirksam werden.
10.4.8.5. src/app/components/person-fields.ts
| // =========================================================================
// components/person-fields.ts - Anrede, Vorname, Nachname
// -------------------------------------------------------------------------
// Die Identitätsfelder, gemeinsam für drei Formulare: Arzt / Client des
// ADMIN, "Create a patient account" und "Manage my account" (das Pendant zum
// Partial views/partials/personFields.hbs). Das Elternelement übergibt ihm die drei
// FELDER seines Signal-Formulars:
// <app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />
// Ein Feld (FieldTree) ist ein Wert wie jeder andere: Es kann
// als Input einer Komponente übergeben werden, die es an ihre eigenen HTML-Elemente bindet.
// =========================================================================
import { Component, input } from '@angular/core';
import { FieldTree, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { InputField } from './input-field';
@Component({
selector: 'app-person-fields',
imports: [FormField, TranslatePipe, InputField],
template: `
<div class="mb-3">
<label class="form-label" for="title">{{ 'PERSONS.TITLE_LABEL' | translate }}</label>
<!-- title(): das als Input empfangene Feld; title()(): sein Zustand -->
@let titleError = title()().errors()[0]?.message;
<select id="title" class="form-select" [formField]="title()" [class.is-invalid]="titleError">
@for (t of TITLES; track t) {
<option [value]="t">{{ t }}</option>
}
</select>
@if (titleError) {
<div class="invalid-feedback">{{ titleError | translate }}</div>
}
</div>
<div class="row g-3 mb-3">
<app-input-field class="col-sm-6" fieldId="firstName" label="PERSONS.FIRSTNAME_LABEL" [formField]="firstName()" [maxChars]="20" mandatory />
<app-input-field class="col-sm-6" fieldId="lastName" label="PERSONS.LASTNAME_LABEL" [formField]="lastName()" [maxChars]="20" mandatory />
</div>
`,
})
export class PersonFields {
readonly title = input.required<FieldTree<string>>();
readonly firstName = input.required<FieldTree<string>>();
readonly lastName = input.required<FieldTree<string>>();
protected readonly TITLES = ['Mr', 'Mme', 'Melle'];
}
|
Die Felder Anrede, Vorname und Nachname, die drei Formularen gemeinsam sind. Das übergeordnete Element übergibt die drei Felder seines signalbasierten Formulars an diese Komponente:
- Zeilen 42–44: Ein Feld ([FieldTree]) ist ein Wert wie jeder andere: Es kann als Input empfangen werden;
- Zeile 25: [title()] ist das als Input empfangene Feld; [title()()] ist sein Status;
- Zeile 26: Die Liste der Anreden wird über [[formField]] mit dem Feld verknüpft;
- Zeilen 36–37: Die beiden anderen Felder werden an die Komponenten [InputField] übergeben.
10.4.8.6. src/app/components/captcha-field.ts
| // =========================================================================
// components/captcha-field.ts - das CAPTCHA-Bild und das Eingabefeld
// -------------------------------------------------------------------------
// Ein selbstgebautes Formular-Steuerelement (FormValueControl, siehe input-field.ts),
// das ein CAPTCHA (GET /api/captcha) lädt, sobald es erzeugt wird. Das Elternelement:
// - bindet den Input an sein Formular: [formField]="f.captcha";
// - holt sich die Komponente selbst mit viewChild(CaptchaField), um
// ihre ÖFFENTLICHEN Methoden aufzurufen: captchaId() und reload() nach
// jedem Versuch, denn ein Bild kann nur EINMAL verwendet werden (der Server
// vergisst es, sobald er es geprüft hat).
//
// [innerHTML] + bypassSecurityTrustHtml: Das SVG-Bild wird unverändert
// eingefügt. HIER unbedenklich, da es von unserem Server erzeugt wird
// (Bibliothek svg-captcha) und nichts enthält, was von einem
// Benutzer stammt - siehe Beispiel 22.
// =========================================================================
import { Component, computed, inject, input, model, signal } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { FormValueControl, ValidationError } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../api/rdvmedecins.api';
import { Captcha } from '../api/types';
@Component({
selector: 'app-captcha-field',
imports: [TranslatePipe],
styles: `
:host {
display: block;
}
`,
template: `
<div class="mb-3">
<label class="form-label" for="captcha">{{ 'CAPTCHA.LABEL' | translate }}</label>
<div class="d-flex align-items-center gap-3 mb-2">
<div class="captcha-image" role="img" [attr.aria-label]="'CAPTCHA.IMAGE_ALT' | translate" [innerHTML]="svg()"></div>
<a href="#" class="small" (click)="$event.preventDefault(); reload()">{{ 'CAPTCHA.NEW_IMAGE' | translate }}</a>
</div>
<input id="captcha" type="text" maxlength="10" autocomplete="off" autocapitalize="off" spellcheck="false"
class="form-control" [class.is-invalid]="error()" [value]="value()" (input)="onInput($event)">
@if (error(); as e) {
<div class="invalid-feedback">{{ e | translate }}</div>
} @else {
<div class="form-text">{{ 'CAPTCHA.HELP' | translate }}</div>
}
</div>
`,
})
export class CaptchaField implements FormValueControl<string> {
readonly value = model('');
readonly errors = input<readonly ValidationError.WithOptionalFieldTree[]>([]);
private readonly api = inject(RdvMedecinsApi);
private readonly sanitizer = inject(DomSanitizer);
private readonly captcha = signal<Captcha | null>(null);
protected readonly svg = computed(() => this.sanitizer.bypassSecurityTrustHtml(this.captcha()?.svg ?? ''));
protected readonly error = computed(() => this.errors()[0]?.message);
constructor() {
this.reload();
}
// ein neues Bild und ein leeres Feld
async reload(): Promise<void> {
this.value.set('');
try {
this.captcha.set(await this.api.captcha());
} catch {
this.captcha.set(null); // Server nicht erreichbar: Die Anmeldung schlägt mit einer klaren Meldung fehl
}
}
// die Kennung des angezeigten Bildes, die mit der Antwort gesendet wird
captchaId(): string {
return this.captcha()?.id ?? '';
}
protected onInput(event: Event): void {
this.value.set((event.target as HTMLInputElement).value);
}
}
|
Das CAPTCHA-Bild und sein Eingabefeld: ein weiteres benutzerdefiniertes Formularsteuerelement.
- Zeile 61: Ein Bild wird geladen, sobald die Komponente erzeugt wird;
- Zeilen 65–72: [reload] ist public: Die Anmeldeseite ruft es nach jedem Versuch auf, da ein Bild nur einmal verwendet wird;
- Zeilen 75–77: die ID des angezeigten Bildes, die mit der Antwort gesendet wird;
- Zeile 37: das SVG-Bild (Beispiel 22) mit Alternativtext für Screenreader;
- Zeile 40: [autocapitalize] und [spellcheck]: keine automatische Großschreibung und keine Rechtschreibprüfung auf einem Smartphone.
Die übergeordnete Seite erhält diese Komponente über [viewChild(CaptchaField)] (Beispiel 13), um ihre öffentlichen Methoden aufzurufen.
10.4.8.7. src/app/components/booking-dialog
| // =========================================================================
// components/booking-dialog/booking-dialog.ts
// -------------------------------------------------------------------------
// Der Dialog zum Buchen eines Zeitfensters. Derselbe Dialog wie
// views/partials/booking.hbs der HTML-Anwendung: die Bootstrap-Klassen
// eines modalen Dialogs, fest codiert angezeigt (show d-block).
//
// Die Komponente spricht nicht mit dem Server: Sie sendet
// - confirm, mit dem gewählten Patienten (null für einen Patienten, der für
// sich selbst bucht);
// - close.
// Die Terminkalender-Seite entscheidet, was damit geschieht (pages/schedule.ts).
// =========================================================================
import { afterNextRender, Component, ElementRef, input, output, signal, viewChild } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { TranslatePipe } from '@ngx-translate/core';
import { Person } from '../../api/types';
import { LabelPipe } from '../../pipes/formatting.pipes';
@Component({
selector: 'app-booking-dialog',
imports: [FormsModule, TranslatePipe, LabelPipe],
// Escape, an beliebiger Stelle der Seite: Wir schließen
host: { '(document:keydown.escape)': 'close.emit()' },
templateUrl: './booking-dialog.html',
})
export class BookingDialog {
readonly time = input.required<string>(); // "8:00 - 8:20"
readonly clients = input<readonly Person[]>([]); // ADMIN / DOCTOR: die Patienten zur Auswahl
readonly patient = input<string | null>(null); // USER: der Patient ist er selbst
readonly submitting = input(false);
readonly confirm = output<number | null>();
readonly close = output<void>();
protected readonly clientId = signal<number | null>(null);
private readonly list = viewChild<ElementRef<HTMLSelectElement>>('list');
private readonly confirmButton = viewChild.required<ElementRef<HTMLButtonElement>>('confirmButton');
constructor() {
// bei der Anzeige: Fokus auf das erste nützliche Element des Dialogs
afterNextRender(() => (this.list() ?? this.confirmButton()).nativeElement.focus());
}
// ein Klick auf den ausgegrauten Hintergrund (und nicht in den Dialog selbst) schließt den Dialog
protected onBackdropClick(e: MouseEvent): void {
if (e.target === e.currentTarget) {
this.close.emit();
}
}
}
|
Das Fenster zur Reservierung eines Zeitraums. Es kommuniziert nicht mit dem Server: Es empfängt, was es anzeigt, und sendet die Entscheidung des Benutzers; die Terminkalender-Seite führt die Aktion aus.
- Zeilen 29–32: Inputs: der Zeitraum, die zur Auswahl stehenden Patienten (ADMIN, DOCTOR) oder der Patient selbst (USER) und ein Indikator „wird gesendet“;
- Zeilen 34–35: Outputs: bestätigen, mit dem ausgewählten Patienten; schließen;
- Zeile 25: Esc schließt das Fenster;
- Zeile 43: [afterNextRender] (Beispiel 13): Sobald das Fenster angezeigt wird, wechselt der Fokus zur Patientenliste oder andernfalls zur Bestätigungsschaltfläche.
| <div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true" aria-labelledby="booking-title"
(click)="onBackdropClick($event)">
<div class="modal-dialog modal-dialog-centered">
<form class="modal-content" (ngSubmit)="confirm.emit(clientId())">
<div class="modal-header">
<h5 id="booking-title" class="modal-title">{{ 'BOOKING_DIALOG.TITLE' | translate }}</h5>
<button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate"
(click)="close.emit()"></button>
</div>
<div class="modal-body">
<p>{{ 'BOOKING_DIALOG.SLOT' | translate: { time: time() } }}</p>
<!-- ein Patient bucht für sich selbst: keine Liste (und der Server
würde eine mögliche clientId ohnehin ignorieren) -->
@if (patient() !== null) {
<p class="mb-0">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}: <strong>{{ patient() }}</strong></p>
} @else {
<label class="form-label" for="clientId">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}</label>
<select #list id="clientId" name="clientId" class="form-select" [(ngModel)]="clientId">
<option [ngValue]="null">{{ 'BOOKING_DIALOG.CHOOSE_PATIENT' | translate }}</option>
@for (c of clients(); track c.id) {
<option [ngValue]="c.id">{{ c | label }}</option>
}
</select>
}
</div>
<div class="modal-footer">
<button type="button" class="btn btn-secondary" (click)="close.emit()">{{ 'BOOKING_DIALOG.CANCEL' | translate }}</button>
<button #confirmButton type="submit" class="btn btn-primary" [disabled]="submitting()">
{{ 'BOOKING_DIALOG.CONFIRM' | translate }}
</button>
</div>
</form>
</div>
</div>
|
- Zeile 5: ein Formular: Die Eingabetaste bestätigt;
- Zeilen 16–26: Ein Patient reserviert für sich selbst: keine Liste;
- Zeilen 21–24: [[ngValue]] (Beispiel 05): Der Wert jeder Option ist eine Zahl oder [null];
- Zeile 31: Die Schaltfläche ist während des Absendens deaktiviert: keine Doppelbuchung durch Doppelklick.
10.4.9. Die Seiten
10.4.9.1. src/app/pages/login
| // =========================================================================
// pages/login/login.ts - die Anmeldeseite (/login)
// -------------------------------------------------------------------------
// Dieselbe Seite wie views/login.hbs der HTML-Anwendung: Login, Passwort,
// CAPTCHA und ein zweiter Button "Create a patient account", der das
// GLEICHE CAPTCHA prüft, bevor er die Kontoerstellung öffnet.
//
// /login?login=jbernard: das Feld login ist vorausgefüllt (direkt nach der
// Erstellung eines Kontos).
// /login?redirect=/doctors: nach der Anmeldung wird diese Seite geöffnet
// (vom Router-Guard dort abgelegt) statt der Startseite der Rolle.
// Diese beiden Parameter kommen als INPUTS der Komponente an.
// =========================================================================
import { afterNextRender, Component, inject, input, signal, viewChild } from '@angular/core';
import { Router } from '@angular/router';
import { form, FormField, required } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { CaptchaField } from '../../components/captcha-field';
@Component({
selector: 'app-login',
imports: [FormField, TranslatePipe, CaptchaField],
templateUrl: './login.html',
})
export class LoginPage {
readonly login = input<string>(); // ?login=...
readonly redirect = input<string>(); // ?redirect=...
private readonly api = inject(RdvMedecinsApi);
private readonly session = inject(SessionService);
private readonly messages = inject(MessagesService);
private readonly router = inject(Router);
protected readonly model = signal({ login: '', password: '', captcha: '' });
// zwei Regeln: login und password sind Pflicht. [formField] setzt dann
// das HTML-Attribut required auf beiden Feldern, und der Browser verweigert
// das Absenden des Formulars, solange sie leer sind
protected readonly f = form(this.model, (p) => {
required(p.login);
required(p.password);
});
private readonly submission = new FormSubmission(this.f);
// die CAPTCHA-Komponente, um ihre Methoden captchaId() und reload() aufzurufen
private readonly captchaField = viewChild.required(CaptchaField);
constructor() {
afterNextRender(() => {
// die Inputs sind jetzt bekannt: das login aus der URL, falls vorhanden
const login = (this.login() ?? '').slice(0, 30);
this.model.update((m) => ({ ...m, login }));
// der Fokus: auf das Passwort, wenn das login bereits ausgefüllt ist
(login ? this.f.password : this.f.login)().focusBoundControl();
});
}
// beide Buttons teilen diesen Ablauf: Absenden und bei einem Fehlschlag
// Fehlermeldung und NEUES Bild (jedes kann nur einmal verwendet werden)
private async attempt(action: () => Promise<unknown>, ignoreValidators = false): Promise<void> {
this.messages.clear();
await this.submission.submit(async () => {
try {
await action();
} catch (e) {
// das neue Bild VOR dem Zuordnen des Fehlers zum Feld:
// reload() leert das Feld, was den Fehler löschen würde
await this.captchaField().reload();
throw e;
}
}, ignoreValidators);
}
protected async logIn(event: Event): Promise<void> {
event.preventDefault();
const { login, password, captcha } = this.model();
await this.attempt(async () => {
await this.session.logIn(login.trim(), password, this.captchaField().captchaId(), captcha);
const redirect = this.redirect();
// nur ein INTERNER Pfad: niemals eine Weiterleitung auf eine andere Website
const internal = redirect !== undefined && redirect.startsWith('/') && !redirect.startsWith('//');
await this.router.navigateByUrl(internal ? redirect : this.session.homePage());
});
}
protected async createAccount(): Promise<void> {
await this.attempt(async () => {
await this.api.registrationAccess(this.captchaField().captchaId(), this.model().captcha);
await this.router.navigate(['/register']);
}, true); // login und password werden hier nicht verwendet: ihre Regeln werden ignoriert
}
}
|
Die Anmeldeseite: Benutzername, Passwort, CAPTCHA und eine zweite Schaltfläche „Create a patient account“, die dasselbe CAPTCHA prüft, bevor die Kontoerstellung zugelassen wird.
- Zeilen 31–32: zwei URL-Parameter: /login?login=jbernard füllt den Benutzernamen vorab aus (unmittelbar nach der Kontoerstellung); /login?redirect=/doctors, vom Guard gesetzt, gibt die nach der Anmeldung zu öffnende Seite an;
- Zeilen 43–46: das einzige Formular der Anwendung mit einem Schema: Benutzername und Passwort sind erforderlich. Die Direktive [[formField]] setzt dann das HTML-Attribut [required] auf beiden Feldern, und der Browser verweigert das Absenden des Formulars, solange sie leer sind;
- Zeile 47: das Absenden des Formulars (services/form-submission.ts);
- Zeile 49: die CAPTCHA-Komponente, um ihre Methoden aufzurufen;
- Zeilen 52–58: [afterNextRender]: Sobald die Seite angezeigt wird, sind die Inputs bekannt. Der Login aus der URL wird in das Formular kopiert (auf 30 Zeichen begrenzt), und der Fokus wird auf das erste leere Feld gesetzt. [focusBoundControl()] setzt den Fokus auf das Element, das durch [[formField]] mit dem Feld verknüpft ist;
- Zeilen 63–75: Beide Schaltflächen folgen dieser Abfolge: absenden und, falls dies fehlschlägt, ein neues Bild (jedes wird nur einmal verwendet). Die Reihenfolge ist wichtig: [reload] leert das CAPTCHA-Feld, wodurch der diesem Feld zugeordnete Fehler entfernt würde; wir laden das Bild daher VORHER neu, um den Fehler erneut auszulösen, den [FormSubmission] dann dem Feld zuordnet;
- Zeilen 77–87: Anmeldung, gefolgt von der Navigation zur angeforderten Seite oder zur Startseite der Rolle. Wie in Beispiel 18 wird nur ein interner Pfad akzeptiert (Zeile 84);
- Zeilen 89–94: die zweite Schaltfläche. Der Server prüft das CAPTCHA und setzt einen „Pass“ (einen Cookie); anschließend öffnet sich die Seite zur Kontoerstellung. Benutzername und Passwort werden hier nicht verwendet: Die Regeln des Schemas werden ignoriert (Zeile 93).
| <div class="row justify-content-center">
<div class="col-sm-8 col-md-6 col-lg-5">
<div class="card p-4">
<h5 class="card-title mb-3">{{ 'LOGIN.TITLE' | translate }}</h5>
<form (submit)="logIn($event)">
<div class="mb-3">
<label class="form-label" for="login">{{ 'LOGIN.LOGIN_LABEL' | translate }}</label>
<input id="login" type="text" class="form-control" autocomplete="username" [formField]="f.login">
</div>
<div class="mb-3">
<label class="form-label" for="password">{{ 'LOGIN.PASSWORD_LABEL' | translate }}</label>
<input id="password" type="password" class="form-control" autocomplete="current-password"
[formField]="f.password">
</div>
<!-- ein selbstgebautes Steuerelement, an das Feld captcha des Formulars gebunden -->
<app-captcha-field [formField]="f.captcha" />
<!-- type="submit": Enter in einem Feld löst "Log in" aus -->
<button type="submit" class="btn btn-primary w-100" [disabled]="f().submitting()">{{ 'LOGIN.SUBMIT' | translate }}</button>
<!-- type="button": dieser Button sendet das Formular nicht ab (keine
required-Prüfung bei Login und Passwort, hier unnötig) -->
<button type="button" class="btn btn-outline-primary w-100 mt-3" [disabled]="f().submitting()" (click)="createAccount()">
{{ 'LOGIN.CREATE_ACCOUNT' | translate }}
</button>
<div class="form-text text-center">{{ 'LOGIN.CREATE_ACCOUNT_HELP' | translate }}</div>
</form>
<div class="text-muted small mt-3">
{{ 'LOGIN.DEMO_ACCOUNTS' | translate }}
<ul class="mb-0 mt-1">
<li><code>admin</code> - {{ 'LOGIN.DEMO_ADMIN' | translate }}</li>
<li><code>pelissier</code>, <code>tatou</code>, <code>dupont</code> - {{ 'LOGIN.DEMO_DOCTOR' | translate }}</li>
<li><code>martin</code>, <code>durand</code>, <code>bistrou</code>, <code>german</code> - {{ 'LOGIN.DEMO_USER' | translate }}</li>
</ul>
</div>
</div>
</div>
</div>
|
- Zeile 6: hier kein [novalidate] : Der Browser meldet einen leeren Benutzernamen oder ein leeres Passwort;
- Zeile 18: das benutzerdefinierte CAPTCHA-Steuerelement, das mit dem Feld [captcha] des Formulars verknüpft ist;
- Zeile 21: Die Schaltfläche ist während des Absendens deaktiviert ([submitting()]);
- Zeile 25: [type="button"]: Diese Schaltfläche sendet das Formular nicht ab, daher verlangt der Browser keinen Benutzernamen und kein Passwort.
10.4.9.2. src/app/pages/schedule
| // =========================================================================
// pages/schedule/schedule.ts - die Terminkalender-Seite (/schedule)
// -------------------------------------------------------------------------
// Drei Blöcke, wie views/schedule.hbs der HTML-Anwendung:
// 1. die Auswahl von Arzt und Tag;
// 2. der Terminkalender dieses Arztes an diesem Tag;
// 3. der Dialog zum Buchen eines Zeitfensters.
//
// Wie in der HTML-Anwendung steckt der GESAMTE Zustand der Seite in ihrer URL:
// /schedule?doctorId=1&day=2026-10-05 der Terminkalender
// /schedule?doctorId=1&day=2026-10-05&book=7 + der Buchungsdialog
// Die Seite kann daher neu geladen und als Lesezeichen gespeichert werden, und die Schaltflächen
// Zurück / Vorwärts des Browsers funktionieren. Die Seite FOLGT ihrer URL: Die drei
// Parameter kommen als INPUTS (Signals) an, und ein Effect lädt den
// Terminkalender neu, wenn sich Arzt oder Tag ändern; die Aktionen des
// Benutzers hingegen ändern die URL (router.navigate).
//
// Was jeder sieht und tun kann, entscheidet der SERVER (Felder
// patient, mine, bookable, appointmentId jedes Zeitfensters): Die Seite zeigt es
// lediglich an. Ein Patient erhält nicht einmal den Namen der anderen Patienten.
// =========================================================================
import { Component, computed, effect, inject, input, signal, untracked } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { FormsModule } from '@angular/forms';
import { TranslatePipe } from '@ngx-translate/core';
import { ApiError } from '../../api/api-error';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { Schedule, ScheduleSlot, Person } from '../../api/types';
import { today, isValidDate, timeRange } from '../../pipes/formatting';
import { TimeRangePipe, LongDatePipe, LabelPipe } from '../../pipes/formatting.pipes';
import { LanguageService } from '../../i18n/language.service';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { BookingDialog } from '../../components/booking-dialog/booking-dialog';
// "3" -> 3; "", "abc", "-2", fehlend -> null
function positiveInteger(value: string | undefined): number | null {
const n = Number(value);
return value !== undefined && value !== '' && Number.isInteger(n) && n > 0 ? n : null;
}
@Component({
selector: 'app-schedule',
imports: [FormsModule, RouterLink, TranslatePipe, TimeRangePipe, LongDatePipe, LabelPipe, BookingDialog],
templateUrl: './schedule.html',
})
export class SchedulePage {
// die Parameter der URL (undefined, wenn sie fehlen)
readonly doctorId = input<string>();
readonly day = input<string>();
readonly book = input<string>();
private readonly api = inject(RdvMedecinsApi);
private readonly router = inject(Router);
protected readonly session = inject(SessionService);
private readonly messages = inject(MessagesService);
private readonly confirmation = inject(ConfirmationService);
protected readonly language = inject(LanguageService).language;
protected readonly doctors = signal<Person[]>([]);
protected readonly clients = signal<Person[]>([]); // ADMIN / DOCTOR: für den Buchungsdialog
protected readonly schedule = signal<Schedule | null>(null);
protected readonly loading = signal(false);
protected readonly submitting = signal(false);
// die Werte des Formulars "Arzt + Tag", aus der URL kopiert
protected readonly doctorChoice = signal<number | null>(null);
protected readonly dayChoice = signal(today());
// der angezeigte Terminkalender ohne Buchungsdialog: die Abfrage "zurück"
protected readonly scheduleQuery = computed(() => ({ doctorId: String(this.doctorChoice() ?? ''), day: this.dayChoice() }));
// das Zeitfenster, dessen Buchungsdialog geöffnet ist (?book=7),
// nur wenn es von diesem Benutzer buchbar ist
protected readonly slotToBook = computed<ScheduleSlot | null>(() => {
const id = positiveInteger(this.book());
return this.schedule()?.slots.find((c) => c.id === id && c.bookable) ?? null;
});
// der Name des angemeldeten Patienten (USER) bzw. null für ADMIN und DOCTOR
protected readonly patient = computed(() => (this.session.isPatient() ? (this.session.user()?.name ?? '') : null));
constructor() {
this.loadLists();
// der Terminkalender folgt der URL (Arzt und Tag): Der Effect LIEST beide Inputs,
// und das Laden erfolgt untracked
effect(() => {
const doctorId = this.doctorId();
const day = this.day();
untracked(() => this.loadSchedule(doctorId, day));
});
}
// -------------------------------------------------------------------------
// Laden
// -------------------------------------------------------------------------
private async loadLists(): Promise<void> {
try {
this.doctors.set(await this.api.list('doctors'));
// die Patientenliste: nur für diejenigen, die sie lesen dürfen
if (this.session.isManager()) {
this.clients.set(await this.api.list('clients'));
}
} catch (e) {
this.messages.showApiError(e);
}
}
private async loadSchedule(urlDoctorId: string | undefined, urlDay: string | undefined): Promise<void> {
// der Tag: der aus der URL, wenn er gültig ist, sonst heute
this.dayChoice.set(today());
if (urlDay !== undefined) {
if (!isValidDate(urlDay)) {
this.schedule.set(null);
this.messages.showError('ERRORS.INVALID_DATE');
return;
}
this.dayChoice.set(urlDay);
}
// der Arzt: der aus der URL; ohne Arzt sieht ein DOCTOR SEINEN bzw. IHREN Terminkalender
// (der Server findet ihn anhand des Tokens)
const doctorId = positiveInteger(urlDoctorId);
this.doctorChoice.set(doctorId);
if (doctorId === null && this.session.role() !== 'DOCTOR') {
this.schedule.set(null);
return;
}
this.loading.set(true);
try {
const schedule = await this.api.schedule(doctorId, this.dayChoice());
this.schedule.set(schedule);
this.doctorChoice.set(schedule.doctor.id);
} catch (e) {
this.schedule.set(null);
this.messages.showApiError(e);
} finally {
this.loading.set(false);
}
}
// der Terminkalender der aktuellen URL, neu gelesen (nach einer Buchung, einer Stornierung)
private reload(): Promise<void> {
return this.loadSchedule(this.doctorId(), this.day());
}
// -------------------------------------------------------------------------
// Aktionen
// -------------------------------------------------------------------------
// "View schedule": Die URL wird geändert, der Terminkalender folgt (Effect oben)
protected viewSchedule(): void {
this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
}
protected closeBooking(): void {
this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
}
protected async confirmBooking(clientId: number | null): Promise<void> {
const slot = this.slotToBook();
if (slot === null) {
return;
}
this.submitting.set(true);
try {
await this.api.book(this.dayChoice(), slot.id, this.session.isManager() ? clientId : null);
this.messages.flash('success', 'SCHEDULE.BOOKED');
} catch (e) {
if (e instanceof ApiError && e.key === 'ERRORS.CHOOSE_PATIENT') {
// kein Patient gewählt: Der Dialog bleibt geöffnet
this.messages.showError(e.key);
return; // (finally wird trotzdem ausgeführt)
}
if (!(e instanceof ApiError)) {
throw e;
}
// Zeitfenster zwischenzeitlich vergeben, Patient hat bereits einen Termin...:
// Die Meldung wird im Terminkalender angezeigt, Dialog geschlossen
this.messages.flash('error', e.key, e.params);
} finally {
this.submitting.set(false);
}
await this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
await this.reload(); // der Server ist die Referenz: Der Terminkalender wird neu gelesen
}
protected async cancel(c: ScheduleSlot): Promise<void> {
if (c.appointmentId === null || !(await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
try {
await this.api.cancelAppointment(c.appointmentId);
this.messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
this.messages.showApiError(e);
}
await this.reload();
}
protected timeRange(c: ScheduleSlot): string {
return timeRange(c);
}
}
|
Die funktionsreichste Seite der Anwendung. Wie in der HTML-Anwendung ist der GESAMTE Zustand der Seite in ihrer URL enthalten: /schedule?doctorId=1&day=2026-10-05 zeigt einen Terminkalender an, &book=7 fügt das Reservierungsfenster hinzu. Sie können die Seite daher neu laden, als Lesezeichen speichern und die Vor-/Zurück-Schaltflächen verwenden. Das Prinzip: Die Seite folgt ihrer URL, und die Aktionen des Benutzers ändern die URL.
- Zeilen 51–53: die drei URL-Parameter als Input;
- Zeilen 39–42: Ein Adressparameter kann beliebigen Inhalt haben; er wird validiert;
- Zeilen 69–70: die Werte des Formulars „Arzt + Tag“, aus der URL kopiert;
- Zeile 73: die Parameter für den angezeigten Terminkalender, ohne Reservierungsfenster;
- Zeilen 77–80: der Zeitraum, für den das Reservierungsfenster geöffnet ist, berechnet aus der Adresse ([?book=7]) und dem Terminkalender: nur wenn er von diesem Benutzer buchbar ist. Ein [computed]: Ändert sich die Adresse, öffnet oder schließt sich das Fenster automatisch;
- Zeilen 89–93: ein Effect, der von den beiden Inputs [doctorId] und [day] abhängt: Der Terminkalender wird neu geladen, sobald sich einer von ihnen ändert. Das Neuladen erfolgt in [untracked]: Die Signale, die es liest und ändert, werden nicht zu Abhängigkeiten des Effects. Der Input [book] wird nicht gelesen: Das Öffnen oder Schließen des Fensters lädt den Terminkalender nicht neu;
- Zeilen 99–109: Ärzte und Patienten für diejenigen, die zu deren Einsicht berechtigt sind;
- Zeilen 111–141: das Laden des Terminkalenders. Ein ungültiges Datum wird gemeldet (Zeilen 115–118); ohne Arzt sieht ein DOCTOR SEINEN EIGENEN Terminkalender: Der Server ermittelt ihn anhand des Tokens (Zeilen 126–129);
- Zeilen 153–159: „View schedule“ und das Schließen des Fensters ändern die Adresse; der Terminkalender folgt;
- Zeilen 161–187: die Terminbuchung. Bei Erfolg wird eine Flash-Meldung vorbereitet (Zeile 169); sie wird nach Zeile 185 angezeigt, die das Fenster schließt. Wurde kein Patient ausgewählt, bleibt das Fenster geöffnet (Zeilen 171–175). Jeder andere Fehler (Zeitraum zwischenzeitlich vergeben usw.) wird im Terminkalender angezeigt, bei geschlossenem Fenster. In allen Fällen wird der Terminkalender neu gelesen: Der Stand des Servers ist maßgeblich (Zeile 186);
- Zeilen 189–200: die Stornierung, nach Bestätigung.
| <!-- 1. die Auswahl von Arzt und Tag -->
<form class="card p-3 mb-3" (ngSubmit)="viewSchedule()">
<div class="row g-2 align-items-end">
<div class="col-sm-5">
<label class="form-label" for="doctorId">{{ 'DOCTOR_DAY_PICKER.DOCTOR_LABEL' | translate }}</label>
<select id="doctorId" name="doctorId" class="form-select" required [(ngModel)]="doctorChoice">
<option [ngValue]="null">{{ 'DOCTOR_DAY_PICKER.CHOOSE_DOCTOR' | translate }}</option>
@for (d of doctors(); track d.id) {
<option [ngValue]="d.id">{{ d | label }}</option>
}
</select>
</div>
<div class="col-sm-4">
<label class="form-label" for="day">{{ 'DOCTOR_DAY_PICKER.DAY_LABEL' | translate }}</label>
<input id="day" name="day" type="date" class="form-control" required [(ngModel)]="dayChoice">
</div>
<div class="col-sm-3">
<button type="submit" class="btn btn-primary w-100">{{ 'DOCTOR_DAY_PICKER.VIEW_SCHEDULE' | translate }}</button>
</div>
</div>
</form>
@let s = schedule();
<!-- Patient mit einem bereits bevorstehenden Termin: der Grund, warum es keinen Button "Book" gibt -->
@if (s?.info; as info) {
<div class="alert alert-info">
{{ info | translate }} <a routerLink="/my-area" class="alert-link">{{ 'APP.MENU_MY_AREA' | translate }}</a>
</div>
}
<!-- 2. der Terminkalender -->
@if (loading() && !s) {
<p class="text-muted">{{ 'APP.LOADING' | translate }}</p>
} @else if (s) {
<div class="card p-3">
<h5>{{ 'SCHEDULE.TITLE_PREFIX' | translate }} {{ s.day | longDate: language() }} - {{ s.doctor | label }}</h5>
@if (s.slots.length > 0) {
<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 (c of s.slots; track c.id) {
<tr [class.free-slot]="c.bookable">
<td>{{ c | timeRange }}</td>
<td>
@if (c.free) {
<span class="badge text-bg-success">{{ 'SCHEDULE.FREE' | translate }}</span>
} @else if (c.patient; as p) {
<span class="badge" [class]="c.mine ? 'text-bg-primary' : 'text-bg-secondary'">{{ p | label }}</span>
} @else {
<span class="badge text-bg-secondary">{{ 'SCHEDULE.BOOKED_BY_OTHER' | translate }}</span>
}
</td>
<td class="text-end">
<!-- "Book" ist ein LINK: er hängt &book=... an die URL an, was den
Buchungsdialog öffnet -->
@if (c.bookable) {
<a class="btn btn-sm btn-outline-success" routerLink="/schedule" [queryParams]="{ doctorId: scheduleQuery().doctorId, day: scheduleQuery().day, book: c.id }">
{{ 'SCHEDULE.BOOK' | translate }}
</a>
}
@if (c.appointmentId !== null) {
<button type="button" class="btn btn-sm btn-outline-danger" (click)="cancel(c)">
{{ 'SCHEDULE.CANCEL_APPOINTMENT' | translate }}
</button>
}
</td>
</tr>
}
</tbody>
</table>
} @else {
<p class="text-muted mb-0">{{ 'SCHEDULE.NO_SLOTS' | translate }}</p>
}
</div>
} @else {
<p class="text-muted">{{ 'SCHEDULE.EMPTY_STATE' | translate }}</p>
}
<!-- 3. der Buchungsdialog, nur wenn die URL &book=... enthält -->
@if (slotToBook(); as c) {
<app-booking-dialog [time]="timeRange(c)" [clients]="clients()" [patient]="patient()"
[submitting]="submitting()" (confirm)="confirmBooking($event)"
(close)="closeBooking()" />
}
|
- Zeilen 2–21: Auswahl des Arztes und des Tages, mit [ngModel] (Beispiel 05);
- Zeile 23: [@let]: der Terminkalender, einmal gelesen;
- Zeilen 26–30: ein Patient, der bereits einen anstehenden Termin hat: Der Server sendet eine Meldung, die erklärt, warum es keine Schaltfläche „Book“ gibt;
- Zeile 37: das Datum ausgeschrieben, in der lokalen Sprache;
- Zeilen 52–58: der Status des Zeitraums: frei, der Patient (blau dargestellt) oder „Booked“, wenn der Server den Namen des Patienten nicht gesendet hat;
- Zeilen 63–67: „Book“ ist ein Link: Er fügt der URL &book=... hinzu, wodurch sich das Reservierungsfenster öffnet;
- Zeilen 87–91: das Reservierungsfenster, nur wenn die URL &book=... enthält und der Zeitraum buchbar ist.
10.4.9.3. src/app/pages/persons/persons.config.ts
| // =========================================================================
// pages/persons/persons.config.ts - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Seiten zur Verwaltung der Ärzte und der Clients sind IDENTISCH: gleiche
// Liste, gleiches Formular. Wie in der HTML-Anwendung (abstrakte Klasse
// PersonsController) werden sie nur EINMAL geschrieben (persons.ts,
// person-form.ts); nur die Adresse der API und die Schlüssel der Beschriftungen
// ändern sich und werden hier beschrieben. Der Router übergibt den Typ in den
// data jeder Route (siehe app.routes.ts).
// =========================================================================
import { PersonType } from '../../api/rdvmedecins.api';
export interface PersonKeys {
title: string; // "Doctors"
add: string; // "Add a doctor"
edit: string; // "Edit a doctor"
empty: string; // "No doctor."
confirmDelete: string;
added: string; // "Doctor {{name}} has been added (login: {{login}})."
edited: string;
deleted: string;
}
export const PERSON_KEYS: 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',
},
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',
},
};
// {{name}} und {{login}} der Meldungen "added / updated / deleted"
export function messageParams(p: { firstName: string; lastName: string; login?: string }): Record<string, string> {
return { name: `${p.firstName} ${p.lastName}`, login: p.login ?? '' };
}
|
Die Seiten zur Verwaltung von Ärzten und Kunden sind identisch: dieselbe Liste, dasselbe Formular. Wie in der HTML-Anwendung (abstrakte Klasse [PersonsController]) werden sie nur einmal geschrieben; Es ändern sich nur die API-Adresse und die Schlüssel der Beschriftungen, die hier beschrieben werden:
- Zeile 25: [Record<PersonType, PersonKeys>]: Der Compiler verlangt für jeden Typ genau einen Eintrag, nicht mehr und nicht weniger;
- Zeilen 49–51: die Parameter für die Meldungen „hinzugefügt / geändert / gelöscht“.
10.4.9.4. src/app/pages/persons
| // =========================================================================
// pages/persons/persons.ts - die Liste der Ärzte ODER der Clients (ADMIN)
// -------------------------------------------------------------------------
// Eine einzige Seite für beide: Der Typ ('doctors' oder 'clients') steckt in
// den data der Route (data.type, siehe app.routes.ts) und kommt als
// INPUT der Komponente an; die jeweils spezifischen Beschriftungen stehen in
// persons.config.ts. Pendant zu views/persons/list.hbs der
// HTML-Anwendung.
// "export default": Die Route lädt die Seite bei Bedarf (loadComponent).
// =========================================================================
import { Component, computed, inject, input, OnInit, signal } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi, PersonType } from '../../api/rdvmedecins.api';
import { Person } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { PERSON_KEYS, messageParams } from './persons.config';
@Component({
selector: 'app-persons',
imports: [RouterLink, TranslatePipe],
templateUrl: './persons.html',
})
export default class PersonsPage implements OnInit {
readonly type = input.required<PersonType>(); // data.type der Route
private readonly api = inject(RdvMedecinsApi);
private readonly messages = inject(MessagesService);
private readonly confirmation = inject(ConfirmationService);
protected readonly keys = computed(() => PERSON_KEYS[this.type()]);
protected readonly persons = signal<Person[] | null>(null); // null: noch nicht geladen
// ngOnInit statt des Konstruktors: Die Inputs (type) sind dann bekannt
ngOnInit(): void {
this.load();
}
private async load(): Promise<void> {
try {
this.persons.set(await this.api.list(this.type()));
} catch (e) {
this.messages.showApiError(e);
}
}
protected async remove(p: Person): Promise<void> {
if (!(await this.confirmation.confirm(this.keys().confirmDelete))) {
return;
}
try {
await this.api.remove(this.type(), p.id);
this.messages.showSuccess(this.keys().deleted, messageParams(p));
} catch (e) {
// ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
this.messages.showApiError(e);
}
await this.load();
}
}
|
- Zeile 26: [export default]: Die Route lädt die Seite bei Bedarf (Beispiel 17);
- Zeile 27: Der Typ (['doctors'] oder ['clients']) stammt aus den Input-Daten der Route;
- Zeile 33: die Schlüssel für die Beschriftungen dieses Typs;
- Zeile 34: [null]: Die Liste wurde noch nicht geladen;
- Zeilen 37–39: [ngOnInit] (Beispiel 13) statt des Konstruktors: Dann sind die Inputs bekannt;
- Zeilen 49–61: das Löschen, nach Bestätigung. Ein Arzt, der noch Termine hat, kann nicht gelöscht werden: Der Server liefert eine 409-Antwort, und ihre Meldung wird angezeigt.
| <div class="d-flex justify-content-between align-items-center mb-3">
<h4 class="mb-0">{{ keys().title | translate }}</h4>
<a class="btn btn-primary" [routerLink]="['/', type(), 'add']">{{ keys().add | translate }}</a>
</div>
<div class="card p-3">
@let list = persons();
@if (list === null) {
<p class="text-muted mb-0">{{ 'APP.LOADING' | translate }}</p>
} @else if (list.length === 0) {
<p class="text-muted mb-0">{{ keys().empty | translate }}</p>
} @else {
<table class="table table-hover align-middle mb-0">
<thead>
<tr>
<th>{{ 'PERSONS.COLUMN_TITLE' | translate }}</th>
<th>{{ 'PERSONS.COLUMN_FIRSTNAME' | translate }}</th>
<th>{{ 'PERSONS.COLUMN_LASTNAME' | translate }}</th>
<th>{{ 'PERSONS.COLUMN_LOGIN' | translate }}</th>
<th></th>
</tr>
</thead>
<tbody>
@for (p of list; track p.id) {
<tr>
<td>{{ p.title }}</td>
<td>{{ p.firstName }}</td>
<td>{{ p.lastName }}</td>
<td><code>{{ p.login }}</code></td>
<td class="text-end">
<div class="d-inline-flex gap-2">
<a class="btn btn-sm btn-outline-primary" [routerLink]="['/', type(), p.id, 'edit']">{{ 'PERSONS.EDIT' | translate }}</a>
<button type="button" class="btn btn-sm btn-outline-danger" (click)="remove(p)">{{ 'PERSONS.DELETE' | translate }}</button>
</div>
</td>
</tr>
}
</tbody>
</table>
}
</div>
|
- Zeile 3: [['/', type(), 'add']]: /doctors/add oder /clients/add;
- Zeilen 8–12: während des Ladens, eine leere Liste, eine Liste;
- Zeile 32: /doctors/3/edit.
10.4.9.5. src/app/pages/person-form
| // =========================================================================
// pages/person-form/person-form.ts - Erstellung ODER Aktualisierung
// eines Arztes oder eines Clients (ADMIN)
// -------------------------------------------------------------------------
// /doctors/add -> Erstellung (kein Input id)
// /doctors/3/edit -> Aktualisierung (Input id = 3)
// (und die gleichen Adressen unter /clients). Pendant zu
// views/persons/form.hbs der HTML-Anwendung.
//
// Hier wird keine Regel geprüft: Der Server validiert alles, und seine Fehler
// werden unter den Feldern angezeigt (siehe services/form-submission.ts).
// Die zusammen mit dem Datensatz gelesene VERSION geht mit der Aktualisierung zurück: Hat ein anderer
// ADMIN ihn zwischenzeitlich aktualisiert, antwortet der Server mit 409 CONCURRENT_UPDATE.
// =========================================================================
import { Component, computed, inject, input, numberAttribute, OnInit, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { ApiError } from '../../api/api-error';
import { RdvMedecinsApi, PersonType } from '../../api/rdvmedecins.api';
import { PersonData } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';
import { PERSON_KEYS, messageParams } from '../persons/persons.config';
@Component({
selector: 'app-person-form',
imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
templateUrl: './person-form.html',
})
export default class PersonFormPage implements OnInit {
readonly type = input.required<PersonType>(); // data.type der Route
// der Parameter :id der Adresse, in eine Zahl umgewandelt; bei einer Erstellung nicht vorhanden
readonly id = input(undefined, { transform: (v: string | undefined) => (v === undefined ? undefined : numberAttribute(v)) });
private readonly api = inject(RdvMedecinsApi);
private readonly messages = inject(MessagesService);
private readonly router = inject(Router);
protected readonly keys = computed(() => PERSON_KEYS[this.type()]);
protected readonly creating = computed(() => this.id() === undefined);
protected readonly model = signal<PersonData>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', version: undefined });
protected readonly f = form(this.model); // kein Validator: Der Server validiert
protected readonly submission = new FormSubmission(this.f);
// Aktualisierung: Der Datensatz wird gelesen (einschließlich seiner Version)
async ngOnInit(): Promise<void> {
const id = this.id();
if (id === undefined) {
return;
}
try {
const p = await this.api.read(this.type(), id);
this.model.set({ title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', password: '', version: p.version });
} catch (e) {
// nicht vorhandener Datensatz (zwischenzeitlich gelöscht...): zurück zur Liste
if (!(e instanceof ApiError)) {
throw e;
}
this.messages.flash('error', e.key, e.params);
this.router.navigate(['/', this.type()]);
}
}
protected async save(event: Event): Promise<void> {
event.preventDefault();
const id = this.id();
const succeeded = await this.submission.submit(async () => {
const data = this.model();
const p = id === undefined ? await this.api.add(this.type(), data) : await this.api.edit(this.type(), id, data);
this.messages.flash('success', this.creating() ? this.keys().added : this.keys().edited, messageParams(p));
});
const key = this.messages.error()?.key;
if (succeeded) {
this.router.navigate(['/', this.type()]);
} else if (key === 'ERRORS.DOCTOR_NOT_FOUND' || key === 'ERRORS.PATIENT_NOT_FOUND') {
// zwischenzeitlich von einem anderen ADMIN gelöscht: zurück zur Liste
this.messages.flash('error', key);
this.router.navigate(['/', this.type()]);
}
}
}
|
Erstellung (/doctors/add) ODER Änderung (/doctors/3/edit) eines Arztes oder Kunden:
- Zeile 37: der Adressparameter [:id], der bei einer Erstellung fehlt. Die Option [transform] wandelt ihn in eine Zahl um ([numberAttribute]);
- Zeile 44: Erstellung oder Änderung?
- Zeilen 46–48: das Formular ohne Validator (der Server validiert alles) und sein Absenden;
- Zeilen 51–67: Bei einer Aktualisierung wird der Datensatz gelesen, einschließlich seiner Version; er wird mit den Änderungen aktualisiert (optimistisches Sperren). Ein nicht vorhandener Datensatz (/doctors/999/edit) leitet mit einer Meldung zur Liste um;
- Zeilen 69–85: das Speichern. Bei Erfolg wird eine Flash-Meldung gesetzt, und der Benutzer wird zur Liste umgeleitet (Zeilen 75 und 78–79). Wurde ein Datensatz zwischenzeitlich von einem anderen Administrator gelöscht, wird der Benutzer ebenfalls zur Liste umgeleitet (Zeilen 80–84); jeder andere Fehler lässt das Formular samt seinen Fehlern angezeigt.
| <div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<div class="card p-4">
<h5 class="card-title mb-3">{{ (creating() ? keys().add : keys().edit) | translate }}</h5>
<!-- novalidate: Es ist der SERVER, der validiert (er ist die Referenz) -->
<form novalidate (submit)="save($event)">
<app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />
<h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
<app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" [formField]="f.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 class="mb-4" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" [maxChars]="72"
autocomplete="new-password" [formField]="f.password" [params]="submission.params()"
[help]="creating() ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'" />
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'PERSONS.SAVE' | translate }}</button>
<a class="btn btn-secondary" [routerLink]="['/', type()]">{{ 'PERSONS.BACK' | translate }}</a>
</div>
</form>
</div>
</div>
</div>
|
- Zeile 6: [novalidate]: Der Server validiert das Formular;
- Zeile 7: Anrede, Vorname und Nachname in einer einzigen Komponente;
- Zeilen 10–15: Benutzername und Passwort, mit einer unterschiedlichen Hilfemeldung für Erstellung und Änderung. Das Passwort wird nie vorausgefüllt: Es wird vom Server nie zurückgegeben;
- Zeile 14: Parameter für die vom Server zurückgegebenen Fehlermeldungen (zum Beispiel die Mindestlänge des Passworts).
10.4.9.6. src/app/pages/register
| // =========================================================================
// pages/register/register.ts - "Create a patient account" (/register)
// -------------------------------------------------------------------------
// Man gelangt nur hierher, nachdem man das CAPTCHA der Anmeldeseite abgetippt hat
// (Button "Create a patient account"): Der Server hat dann einen
// Pass ausgestellt, den der Guard der Route geprüft hat (siehe guards.ts).
// Gleiche Felder wie im ADMIN-Formular, aber login und password
// sind Pflicht, mit Bestätigung. Pendant zu
// views/account/registration.hbs der HTML-Anwendung.
// =========================================================================
import { Component, computed, inject, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { Registration } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';
// Mindestlänge eines von einem Patienten gewählten Passworts: gleicher Wert
// wie auf dem Server (der mit dem Fehler PASSWORD_TOO_SHORT auch {min} zurückgibt)
const PASSWORD_MIN = '6';
@Component({
selector: 'app-register',
imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
templateUrl: './register.html',
})
export default class RegisterPage {
private readonly api = inject(RdvMedecinsApi);
private readonly messages = inject(MessagesService);
private readonly router = inject(Router);
protected readonly model = signal<Registration>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' });
protected readonly f = form(this.model);
protected readonly submission = new FormSubmission(this.f);
// die Parameter der Hilfemeldung UND der Fehler des Passworts
protected readonly passwordParams = computed(() => ({ min: PASSWORD_MIN, ...this.submission.params() }));
protected async create(event: Event): Promise<void> {
event.preventDefault();
let login = '';
const succeeded = await this.submission.submit(async () => {
login = (await this.api.register(this.model())).login;
});
if (succeeded) {
// zurück zur Anmeldeseite, login vorausgefüllt
this.messages.flash('success', 'REGISTRATION.DONE', { login });
this.router.navigate(['/login'], { queryParams: { login } });
} else if (this.messages.error()?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
// abgelaufener Pass (15 Minuten): zurück zum CAPTCHA
this.messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
this.router.navigate(['/login']);
}
}
}
|
Erstellung eines Patientenkontos. Man gelangt hier nur mit dem Token weiter, das der Server nach dem Lösen des CAPTCHA ausstellt (guards.ts):
- Zeile 25: die Mindestlänge des Passworts; für die Hilfemeldung: derselbe Wert wie beim Server;
- Zeile 41: die Parameter für die Hilfemeldung und die Fehlermeldungen zum Passwort. Die Parameter des Servers, falls welche zurückgegeben werden, haben Vorrang (sie werden zuletzt gesetzt);
- Zeilen 46–48: das Absenden; der Server gibt den Benutzernamen des erstellten Kontos zurück;
- Zeilen 49–52: Rückkehr zur Anmeldeseite, mit vorausgefülltem Benutzernamen;
- Zeilen 53–57: Das Token ist abgelaufen (15 Minuten): Rückkehr zum CAPTCHA.
| <div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<div class="card p-4">
<h5 class="card-title mb-1">{{ 'REGISTRATION.TITLE' | translate }}</h5>
<p class="text-muted small mb-3">{{ 'REGISTRATION.INTRO' | translate }}</p>
<form novalidate (submit)="create($event)">
<app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />
<h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
<app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" autocomplete="username"
mandatory [formField]="f.login" help="REGISTRATION.LOGIN_HELP" />
<div class="row g-3 mb-3">
<app-input-field class="col-sm-6" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" [maxChars]="72"
autocomplete="new-password" mandatory [formField]="f.password" [params]="passwordParams()"
help="REGISTRATION.PASSWORD_HELP" />
<app-input-field class="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
[maxChars]="72" autocomplete="new-password" mandatory [formField]="f.confirmation" />
</div>
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'REGISTRATION.SUBMIT' | translate }}</button>
<a class="btn btn-secondary" routerLink="/login">{{ 'REGISTRATION.BACK_TO_LOGIN' | translate }}</a>
</div>
</form>
</div>
</div>
</div>
|
- Zeile 7: Anrede, Vorname, Nachname;
- Zeilen 10–17: Benutzername, Passwort und Passwortbestätigung – diesmal erforderlich (das Attribut [mandatory] liefert nur einen Hinweis: Der Server entscheidet).
10.4.9.7. src/app/pages/patient-area
| // =========================================================================
// pages/patient-area/patient-area.ts - "My area" (/my-area, Rolle USER)
// -------------------------------------------------------------------------
// Die Startseite des Patienten direkt nach der Anmeldung:
// - zwei Optionen: [Manage my account] und [View a schedule];
// - sein bevorstehender Termin, falls vorhanden, mit der Möglichkeit, ihn zu stornieren.
// Pendant zu views/patient/area.hbs der HTML-Anwendung.
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { MyArea } from '../../api/types';
import { TimeRangePipe, LongDatePipe, LabelPipe } from '../../pipes/formatting.pipes';
import { LanguageService } from '../../i18n/language.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
@Component({
selector: 'app-patient-area',
imports: [RouterLink, TranslatePipe, TimeRangePipe, LongDatePipe, LabelPipe],
templateUrl: './patient-area.html',
})
export default class PatientAreaPage {
private readonly api = inject(RdvMedecinsApi);
private readonly messages = inject(MessagesService);
private readonly confirmation = inject(ConfirmationService);
protected readonly language = inject(LanguageService).language;
protected readonly area = signal<MyArea | null>(null);
constructor() {
this.load();
}
private async load(): Promise<void> {
try {
this.area.set(await this.api.myArea());
} catch (e) {
this.messages.showApiError(e);
}
}
protected async cancel(appointmentId: number): Promise<void> {
if (!(await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
try {
await this.api.cancelAppointment(appointmentId);
this.messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
this.messages.showApiError(e);
}
await this.load();
}
}
|
Die Startseite des Patienten: zwei Optionen („Manage my account“, „View a schedule“) und sein anstehender Termin, den er stornieren kann (Zeilen 45–56).
| @if (area(); as a) {
<h4 class="mb-3">{{ 'AREA.HELLO' | translate: { name: (a.patient | label) } }}</h4>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<a class="card p-4 h-100 text-decoration-none option-card" routerLink="/my-account">
<h5 class="mb-1">{{ 'AREA.MANAGE_ACCOUNT' | translate }}</h5>
<span class="text-muted">{{ 'AREA.MANAGE_ACCOUNT_HELP' | translate }}</span>
</a>
</div>
<div class="col-sm-6">
<a class="card p-4 h-100 text-decoration-none option-card" routerLink="/schedule">
<h5 class="mb-1">{{ 'AREA.VIEW_SCHEDULE' | translate }}</h5>
<span class="text-muted">{{ 'AREA.VIEW_SCHEDULE_HELP' | translate }}</span>
</a>
</div>
</div>
<div class="card p-3">
<h5>{{ 'AREA.MY_APPOINTMENT' | translate }}</h5>
<!-- normalerweise nur einer (Regel "ein bevorstehender Termin zur Zeit"),
aber die Seite kann mehrere anzeigen -->
@for (appointment of a.appointments; track appointment.id; let last = $last) {
<div class="d-flex flex-wrap justify-content-between align-items-center gap-2 py-2" [class.border-bottom]="!last">
<div>
<div class="fw-semibold">{{ appointment.day | longDate: language() }}, {{ appointment.slot | timeRange }}</div>
<div class="text-muted">
{{ appointment.doctor | label }} -
<!-- der Terminkalender des Arztes an diesem Tag: Der Patient sieht dort seinen Namen -->
<a routerLink="/schedule" [queryParams]="{ doctorId: appointment.doctor.id, day: appointment.day }">{{ 'AREA.SEE_IN_SCHEDULE' | translate }}</a>
</div>
</div>
<button type="button" class="btn btn-outline-danger" (click)="cancel(appointment.id)">{{ 'AREA.CANCEL_APPOINTMENT' | translate }}</button>
</div>
} @empty {
<p class="text-muted mb-0">{{ 'AREA.NO_APPOINTMENT' | translate }}</p>
}
</div>
} @else {
<p class="text-muted">{{ 'APP.LOADING' | translate }}</p>
}
|
- Zeile 2: ein Übersetzungsparameter, der von einer Pipe berechnet wird;
- Zeile 22: [$last]: Die letzte Zeile hat keinen Rahmen;
- Zeile 29: ein Link zum Terminkalender des Arztes für diesen Tag.
10.4.9.8. src/app/pages/my-account
| // =========================================================================
// pages/my-account/my-account.ts - "Manage my account" (/my-account, Rolle USER)
// -------------------------------------------------------------------------
// Zwei voneinander unabhängige Formulare, wie views/patient/account.hbs:
// 1. die Aktualisierung (Identität, login, optionales neues Passwort);
// 2. das Löschen des Kontos - wodurch auch seine Termine storniert werden.
// Beide verlangen das AKTUELLE Passwort (vom Server geprüft).
// Zwei Formulare, also zwei Modelle, zwei Feldbäume und zwei
// FormSubmission-Objekte (zwei Fehlermengen).
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { MyAccountUpdate } from '../../api/types';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';
@Component({
selector: 'app-my-account',
imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
templateUrl: './my-account.html',
})
export default class MyAccountPage {
private readonly api = inject(RdvMedecinsApi);
private readonly session = inject(SessionService);
private readonly messages = inject(MessagesService);
private readonly confirmation = inject(ConfirmationService);
private readonly router = inject(Router);
// 1. die Aktualisierung
protected readonly model = signal<MyAccountUpdate>({
title: 'Mr',
firstName: '',
lastName: '',
login: '',
password: '',
confirmation: '',
currentPassword: '',
version: 0,
});
protected readonly f = form(this.model);
protected readonly update = new FormSubmission(this.f);
// 2. das Löschen: ein Formular mit einem einzigen Feld
protected readonly deletionModel = signal({ currentPassword: '' });
protected readonly fs = form(this.deletionModel);
protected readonly deletion = new FormSubmission(this.fs);
constructor() {
this.load();
}
private async load(): Promise<void> {
try {
const account = await this.api.myAccount();
this.model.update((m) => ({ ...m, ...account }));
} catch (e) {
this.messages.showApiError(e);
}
}
protected async save(event: Event): Promise<void> {
event.preventDefault();
const succeeded = await this.update.submit(async () => {
// der Server hat ein NEUES Token ausgestellt (name, login): Die Navigationsleiste
// muss folgen
this.session.update(await this.api.editMyAccount(this.model()));
this.messages.flash('success', 'MY_ACCOUNT.UPDATED');
});
if (succeeded) {
this.router.navigate(['/my-area']);
} else {
// niemals ein Passwort im Feld belassen nach einem abgelehnten Absenden;
// geändert wird das Feld selbst (und nicht das Modell), um die Fehler nicht zu löschen,
// die der Server ihm gerade zugeordnet hat... außer seinen eigenen
this.f.currentPassword().value.set('');
}
}
protected async deleteAccount(event: Event): Promise<void> {
event.preventDefault();
if (!(await this.confirmation.confirm('MY_ACCOUNT.DELETE_CONFIRM'))) {
return;
}
const succeeded = await this.deletion.submit(() => this.api.deleteMyAccount(this.deletionModel().currentPassword));
if (succeeded) {
this.session.forget(); // der Server hat den Cookie des Tokens gelöscht
this.messages.flash('success', 'MY_ACCOUNT.DELETED');
this.router.navigate(['/login']);
}
}
}
|
Zwei unabhängige Formulare: Kontoänderung und Kontolöschung. Beide erfordern das aktuelle Passwort, das vom Server geprüft wird. Zwei Formulare, also zwei Modelle, zwei Feldbäume und zwei [FormSubmission]: Fehler im einen erscheinen nicht im anderen.
- Zeilen 60–67: Das Konto wird gelesen, und seine Werte werden in das Modell kopiert (einschließlich der Version);
- Zeile 74: Nach einer Änderung gibt der Server den aktualisierten Benutzer zurück (und hat ein neues Token ausgestellt): Die Navigationsleiste muss entsprechend aktualisiert werden;
- Zeile 83: Nach einem abgelehnten Absenden wird das aktuelle Passwort geleert. Wir aktualisieren das Feld (nicht das gesamte Formular): Nur der Fehler dieses Feldes verschwindet; die anderen bleiben angezeigt;
- Zeilen 87–98: die Kontolöschung, nach Bestätigung. Der Server hat den Token-Cookie gelöscht: Der Benutzer wird vergessen, und die Seite kehrt zur Anmeldeseite zurück.
| <div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<!-- 1. Aktualisierung -->
<div class="card p-4 mb-4">
<h5 class="card-title mb-3">{{ 'MY_ACCOUNT.TITLE' | translate }}</h5>
<form novalidate (submit)="save($event)">
<app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />
<h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
<app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" autocomplete="username"
mandatory [formField]="f.login" />
<div class="row g-3 mb-3">
<app-input-field class="col-sm-6" fieldId="password" type="password" label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
[maxChars]="72" autocomplete="new-password" [formField]="f.password"
[params]="update.params()" help="PERSONS.PASSWORD_HELP_EDIT" />
<app-input-field class="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
[maxChars]="72" autocomplete="new-password" [formField]="f.confirmation" />
</div>
<app-input-field class="mb-4" fieldId="currentPassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
[maxChars]="72" autocomplete="current-password" mandatory [formField]="f.currentPassword"
help="MY_ACCOUNT.CURRENT_PASSWORD_HELP" />
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'PERSONS.SAVE' | translate }}</button>
<a class="btn btn-secondary" routerLink="/my-area">{{ 'MY_ACCOUNT.BACK' | translate }}</a>
</div>
</form>
</div>
<!-- 2. Löschen -->
<div class="card p-4 border-danger">
<h5 class="card-title text-danger mb-1">{{ 'MY_ACCOUNT.DELETE_TITLE' | translate }}</h5>
<p class="text-muted small">{{ 'MY_ACCOUNT.DELETE_HELP' | translate }}</p>
<form class="d-flex flex-wrap gap-2 align-items-end" novalidate (submit)="deleteAccount($event)">
<app-input-field class="flex-grow-1" fieldId="deletePassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
[maxChars]="72" autocomplete="current-password" mandatory [formField]="fs.currentPassword" />
<button type="submit" class="btn btn-danger" [disabled]="fs().submitting()">{{ 'MY_ACCOUNT.DELETE_SUBMIT' | translate }}</button>
</form>
</div>
</div>
</div>
|
10.4.9.9. src/app/pages/error/error.ts
| // =========================================================================
// pages/error/error.ts - die Fehlerseite: 404 (unbekannte Adresse) oder 403
// (unzureichende Rolle, siehe guards.ts). Pendant zu views/error.hbs.
// Der Code kommt als Input an, aus den data der Route (data.code).
// =========================================================================
import { Component, computed, input } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
@Component({
selector: 'app-error',
imports: [RouterLink, TranslatePipe],
template: `
<div class="card p-4">
<h4 class="text-danger">{{ 'ERROR_PAGE.TITLE' | translate }} {{ code() }}</h4>
<p>{{ message() | translate }}</p>
<a routerLink="/" class="btn btn-primary align-self-start">{{ 'ERROR_PAGE.BACK' | translate }}</a>
</div>
`,
})
export default class ErrorPage {
readonly code = input.required<403 | 404>();
protected readonly message = computed(() => (this.code() === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND'));
}
|
Die Fehlerseite, 403 oder 404: Der Code wird als Input aus den Routendaten übergeben ([data.code]).