10. Fallstudie: Der React-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 die Client-Anwendung [React]: dieselben Seiten, im Browser aus den JSON-Daten des Servers erzeugt, der im Kapitel „Der RdvMedecins-Server: eine Blackbox“ beschrieben wurde.
Der Client muss alles bieten, was die HTML-Anwendung bot:
- eine Anmeldeseite, durch ein CAPTCHA geschützt, mit der Möglichkeit, ein Patientenkonto zu erstellen;
- der Terminkalender eines Arztes für einen bestimmten Tag, mit Terminbuchung (Fenster zur Patientenauswahl) und Stornierung;
- für den Administrator die Verwaltung von Ärzten und Klienten (Liste, Hinzufügen, Bearbeiten, Löschen);
- für den Patienten ein persönliches Dashboard (mit den bevorstehenden Terminen, die er stornieren kann) und die Kontoverwaltung;
- zwei Sprachen: Französisch und Englisch;
- eindeutige URLs ([/schedule?doctorId=1&day=...]), die sich neu laden, als Lesezeichen speichern und mit den Schaltflächen Zurück/Vor des Browsers durchlaufen lassen.
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 nutzen, benötigen Sie den CAPTCHA-Testmodus nicht: Sie können das Feld [CAPTCHA_TEST] in der Datei [.env] des Servers leer lassen.
In einem Konsolenfenster, das im Ordner [rdvmedecins-react] geöffnet ist:
Öffnen Sie dann http://localhost:5173 in einem Browser. Die Demo-Konten sind auf der Anmeldeseite aufgeführt (Passwort = Login).
Die Beispiele verwenden ebenfalls Port 5173: Beenden Sie zuerst das gerade laufende Beispiel ([Ctrl-C]). Sie können den Client auch auf einem anderen Port starten: [npm start -- --port 5174].
10.3. Die Anwendung verwenden
10.3.1. Die Anmeldeseite

Ein falsches Passwort: Die Meldung erscheint am unteren Seitenrand, und ein neues Bild wird angezeigt (jedes Bild kann nur einmal verwendet werden):

10.3.2. Der Terminkalender, wie ihn der Administrator und die Ärzte sehen
Als [admin] angemeldet, 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]: Das Neuladen der Seite (F5) öffnet dasselbe Fenster erneut.

Der Termin wird gespeichert:

„Cancel“ fordert zur Bestätigung auf:

Ein Arzt wird direkt zu SEINEM EIGENEN Tagesterminkalender geleitet:

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

In einem Terminkalender sieht er „Booked“ neben den Zeitfenstern der Termine anderer Patienten:

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 bevorstehender Termin), und eine Meldung erklärt den Grund:

Sein Dashboard zeigt Folgendes:

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

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

10.3.4. Ärzte und Klienten verwalten

Ein falsch ausgefülltes Formular:

Ein erfolgreiches Hinzufügen:

Ein Namensvetter:

Die Anfrage, einen Arzt zu löschen, der noch Termine hat, wird abgelehnt:

10.3.5. Ein Konto erstellen
Geben Sie auf der Anmeldeseite das CAPTCHA ein und klicken Sie dann auf „Patientenkonto erstellen“. Das Formular wurde fehlerhaft ausgefüllt und vom Server abgelehnt:

Kehren Sie nach der Erstellung des Kontos zur Anmeldeseite zurück; die Anmeldefelder sind vorausgefüllt:

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

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

Eine unbekannte Adresse:

10.4. Client-Architektur
| rdvmedecins-react/
├── package.json, vite.config.ts, tsconfig.json
├── index.html THE page of the application
├── public/favicon.svg the tab icon
└── src/
├── main.tsx the startup
├── router.ts the router, the expired session, the flash messages
├── routes.tsx the pages and their access rights
├── guards.ts the router guards
├── styles.css
├── formatting.ts the formatting
├── api/ the API access layer
├── i18n/ the languages
├── stores/ session, messages, confirmation (Zustand)
├── hooks/ form submission, the captcha
├── components/ the layout and the reusable components
└── pages/ the pages
|

Die folgende Tabelle vergleicht die HTML-Anwendung aus dem Kurs [NestJS] mit diesem Client:
HTML-Anwendung (NestJS) | React-Client |
Der Server erzeugt jede Seite ([res.render]) | Der Server liefert JSON; die Komponenten in [src/pages/] erzeugen die Seiten |
[views/layout.hbs] und seine Partial Views | [Layout.tsx] und die Komponenten in [src/components/] |
die Routen des Controllers ([@Controller('schedule')]) | Routen des Clients ([routes.tsx]); der Server hat nur noch /api/...-Routen |
[JwtAuthGuard] und [RolesGuard] leiten zu /login oder zu einer 403-Seite um | Router-Guards; der Server unterhält eigene Guards, die 401 oder 403 zurückgeben |
Flash-Meldung in einem Cookie | Flash-Meldung in einem Store, [useMessages] |
vom Server gelesene Wörterbücher, Helfer [{{t}}] | Wörterbücher auf dem Client, [i18next]; der Server liefert nur Schlüssel |
in einem Cookie gespeicherte Sprache | Sprache, gespeichert im [localStorage] |
Formular abgelehnt: Der Server lädt die Seite neu | Formular abgelehnt: Antwort 400/409; der Client zeigt die Fehler unter den Feldern an |
Bestätigungsfenster: ein kleines Skript, [public/js/app.js] | ein Store und eine Komponente, [ConfirmDialog] |
Die Anwendung funktioniert ohne JavaScript | Die Anwendung IST JavaScript |
Die Clients [Vue.js] und [Angular] aus den vorherigen Lektionen haben exakt dieselbe Struktur: Die „Stores“ in [Pinia] und die Services in [Angular] entsprechen hier den [Zustand]-Stores; die „Composables“ sind die Hooks, und die Views sind die Seiten.
Alle Dateien des Clients sind unten aufgeführt. Sie sind ausführlich kommentiert; ihre Kommentare sind Teil des Kurses.
10.4.1. Projektkonfiguration
10.4.1.1. package.json
| {
"name": "rdvmedecins-react",
"private": true,
"version": "1.0.0",
"description": "React client of the medical appointment booking application [RdvMedecins] - client of the JSON server [rdvmedecins-nestjs-json]",
"type": "module",
"scripts": {
"start": "vite",
"build": "tsc --noEmit && vite build",
"preview": "vite preview"
},
"dependencies": {
"@tanstack/react-query": "^5.104.0",
"bootstrap": "^5.3.8",
"i18next": "^26.4.2",
"react": "^19.3.0",
"react-dom": "^19.3.0",
"react-i18next": "^17.0.15",
"react-router": "^8.4.0",
"zustand": "^5.0.15"
},
"devDependencies": {
"@types/react": "^19.2.18",
"@types/react-dom": "^19.2.7",
"@vitejs/plugin-react": "^6.1.1",
"typescript": "~6.0.2",
"vite": "^8.3.0"
}
}
|
- Zeilen 8–10: [npm start] startet den Entwicklungsserver; [npm run build] prüft die Typen ([tsc --noEmit], siehe unten) und erstellt DANN die Produktionsversion; [npm run preview] stellt die erstellte Version zum Testen bereit;
- Zeilen 12–21: die von der Anwendung verwendeten Bibliotheken: [React], [React Router], [TanStack Query], [Zustand], [i18next], [Bootstrap];
- Zeilen 22–28: Entwicklungswerkzeuge: [Vite] und seine Erweiterung für [React], [TypeScript] und die Typen von [React].
Es gibt keine Formularbibliothek ([React Hook Form], Beispiel 08): Wie in Beispiel 25 werden alle Validierungsregeln für Eingaben vom Server geprüft, und der Client zeigt lediglich die Ergebnisse an.
10.4.1.2. vite.config.ts
| // =========================================================================
// vite.config.ts - das Build-Tool des Clients
// -------------------------------------------------------------------------
// - npm start : der Entwicklungsserver (http://localhost:5173),
// der /api/... an den JSON-Server (Port 8080) weiterleitet;
// - npm run build : die kompilierte Anwendung, in dist/;
// - npm run preview: liefert dist/ aus (mit demselben Proxy), zum Ausprobieren.
// =========================================================================
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
// der Proxy: Seiten und API haben so DENSELBEN Origin (localhost:5173); das
// httpOnly-Cookie des Tokens wird ohne jede Konfiguration mitgesendet, und es gibt kein CORS
const proxy = { '/api': 'http://localhost:8080' };
export default defineConfig({
plugins: [react()],
server: { port: 5173, proxy },
preview: { port: 4173, proxy },
// in der Produktion: der Code der Bibliotheken (React, React Router,
// i18next...) in EINER separaten Datei, "libraries-XXXX.js". Sie ändert sich
// selten: Der Browser hält sie von einer Version zur nächsten in seinem Cache.
build: {
rolldownOptions: {
output: { codeSplitting: { groups: [{ name: 'libraries', test: /node_modules/ }] } },
},
},
});
|
- Zeile 15: der Proxy aus Beispiel 22: Anfragen an /api/... werden an den JSON-Server weitergeleitet;
- Zeile 19: der Entwicklungsserver;
- Zeile 20: der Server von [npm run preview] mit demselben Proxy;
- Zeilen 24–28: In der Produktion wird der Code der Bibliotheken in einer separaten Datei abgelegt (siehe Kapitel „Bereitstellung“).
10.4.1.3. tsconfig.json
| {
"compilerOptions": {
"target": "ES2023",
"lib": ["ES2023", "DOM", "DOM.Iterable"],
"module": "ESNext",
"moduleResolution": "bundler",
"types": ["vite/client"],
"jsx": "react-jsx",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
"verbatimModuleSyntax": true,
"erasableSyntaxOnly": true,
"resolveJsonModule": true,
"skipLibCheck": true,
"noEmit": true
},
"include": ["src", "vite.config.ts"]
}
|
- Zeile 8: JSX wird in Aufrufe von [jsx(...)] kompiliert, die automatisch importiert werden: [import React] ist nicht in jeder Datei nötig;
- Zeile 9: der strikte Modus von [TypeScript];
- Zeile 14: ein Import, der nur für Typen verwendet wird, wird als [import type] geschrieben: Er verschwindet bei der Kompilierung;
- Zeile 15: Erlaubt ist nur [TypeScript]-Syntax, die sich einfach ENTFERNEN lässt, um [JavaScript] zu erhalten (kein [enum], keine Property-Parameter): Genau das tut [Vite], das die Typen nicht prüft;
- Zeile 16: der Import der JSON-Dateien (der Wörterbücher);
- Zeile 18: [TypeScript] erzeugt keine Dateien: Es PRÜFT nur ([tsc --noEmit]); [Vite] ist es, das kompiliert.
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 React in <div id="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>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="/favicon.svg" type="image/svg+xml">
</head>
<body>
<div id="root"></div>
<!-- ohne JavaScript kann eine React-Anwendung nichts anzeigen: Wir sagen das -->
<noscript>RdvMedecins requires JavaScript. / RdvMedecins a besoin de JavaScript.</noscript>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
|
- Zeile 16: das Element, in dem [React] die Anwendung anzeigt;
- Zeile 18: Ohne [JavaScript] kann eine [React]-Anwendung nichts anzeigen: Das wird hier mitgeteilt;
- Zeile 19: der Einstiegspunkt der Anwendung. Während der Entwicklung kompiliert [Vite] bei Bedarf [main.tsx] ; in der Produktion wird diese Zeile durch die kompilierte Datei ersetzt (siehe Kapitel „Bereitstellung“).
10.4.2.2. src/main.tsx
| // =========================================================================
// main.tsx - der Start der Anwendung
// -------------------------------------------------------------------------
// - die Stylesheets (Bootstrap, styles.css);
// - i18next (Französisch und Englisch);
// - TanStack Query, das die Daten des Servers liest: Seine fehlgeschlagenen Anfragen
// zeigen ihre Meldung im Fehlerpanel an, an EINER
// Stelle (außer denen, die erklären, ihren Fehler selbst zu behandeln:
// meta.errorHandled);
// - der Router, der die Seite der aktuellen Adresse anzeigt.
// =========================================================================
import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { QueryCache, QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import './styles.css';
import './i18n/i18n';
import { useMessages } from './stores/messages';
import { router } from './router';
const queryClient = new QueryClient({
queryCache: new QueryCache({
onError: (error, query) => {
if (!query.meta?.errorHandled) {
useMessages.getState().showApiError(error);
}
},
}),
defaultOptions: {
queries: {
retry: false, // ein Fehler wird sofort angezeigt, ohne neuen Versuch
refetchOnWindowFocus: false, // kein erneutes Lesen bei der Rückkehr zum Tab
},
},
});
createRoot(document.getElementById('root')!).render(
<StrictMode>
<QueryClientProvider client={queryClient}>
<RouterProvider router={router} />
</QueryClientProvider>
</StrictMode>,
);
|
- Zeilen 17–19: die Stylesheets, gefolgt von der Konfiguration von [i18next], die einmalig beim Laden des Moduls ausgeführt wird;
- Zeilen 23–37: der Client von [TanStack Query] (Beispiel 24) mit zwei Einstellungen:
- Zeilen 24–30: [onError] wird bei JEDER fehlgeschlagenen Anfrage aufgerufen: Deren Fehlermeldung wird an einer einzigen Stelle im Fehlerbereich angezeigt. Eine Abfrage, die ihren Fehler selbst behandelt, deklariert dies in ihren Metadaten: [meta: { errorHandled: true }];
- Zeilen 33–34: Standardmäßig wiederholt [TanStack Query] eine fehlgeschlagene Anfrage dreimal und lädt die Daten neu, wenn Sie zum Tab zurückkehren: Hier wird ein Fehler sofort angezeigt, und die Daten ändern sich nur auf Anforderung;
- Zeile 42: Der Router (erstellt in [router.ts]) zeigt die Seite für die aktuelle Adresse an.
10.4.2.3. src/router.ts
| // =========================================================================
// router.ts - der Router der Anwendung und was von ihm abhängt
// -------------------------------------------------------------------------
// Der Router wird hier außerhalb jeder Komponente erstellt, damit zwei
// Mechanismen ihn nutzen können:
// 1. die Antwort 401 einer geschützten Anfrage (Sitzung abgelaufen): Der
// Benutzer wird vergessen, die Meldung wird vorbereitet, und wir gehen zur
// Login-Seite (siehe api/client.ts);
// 2. die „Flash“-Meldungen: Am Ende JEDER Navigation verschwinden die Meldungen
// der vorherigen Seite, und die für die nächste
// Seite hinterlassenen erscheinen (siehe stores/messages.ts).
// =========================================================================
import { createBrowserRouter } from 'react-router';
import { routes } from './routes';
import { whenSessionExpired } from './api/client';
import { useSession } from './stores/session';
import { useMessages } from './stores/messages';
export const router = createBrowserRouter(routes);
// 1. die abgelaufene Sitzung
whenSessionExpired(() => {
useSession.getState().forget();
useMessages.getState().flash('error', 'ERRORS.SESSION_EXPIRED');
router.navigate('/login');
});
// 2. subscribe: Die Funktion wird bei jeder Zustandsänderung des
// Routers aufgerufen. Eine Navigation ist BEENDET, wenn sie nicht mehr in Bearbeitung ist
// (idle) und sich die Adresse geändert hat (jede besuchte Adresse hat einen eindeutigen Schlüssel,
// location.key - auch wenn sich nur die Parameter ändern: /schedule?...)
let locationKey = router.state.location.key;
router.subscribe((state) => {
if (state.navigation.state === 'idle' && state.location.key !== locationKey) {
locationKey = state.location.key;
useMessages.getState().newPage();
}
});
|
- Zeile 20: Der Router im „Data“-Modus (Beispiel 17) wird AUSSERHALB jeder Komponente erstellt: Code, der keine Komponente ist, kann ihn somit verwenden ([router.navigate]);
- Zeilen 23–27: was zu tun ist, wenn eine geschützte Anfrage eine 401-Antwort erhält (siehe [api/client.ts]): den Benutzer vergessen, die Meldung für die nächste Seite vorbereiten, zur Anmeldeseite wechseln;
- Zeilen 33–39: [router.subscribe(function)]: Die Funktion wird aufgerufen, sobald sich der Zustand des Routers ändert. Am Ende jeder Navigation verschwinden die Meldungen der vorherigen Seite, und die „Flash“-Meldungen erscheinen (siehe [stores/messages.ts]).
10.4.2.4. 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/ErrorPanel.tsx).
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 grauen Hintergrund der modalen Dialoge.
pointer-events: none: Das Panel enthält nichts Klickbares; überlappt es
einen Button, geht der Klick hindurch.
------------------------------------------------------------------------- */
.error-panel {
position: sticky;
bottom: 1rem;
z-index: 1060;
pointer-events: none;
margin-top: 1.5rem;
padding: 0.75rem 1rem;
background-color: #fdecef; /* hellrosa */
border: 1px solid #f5c2c7;
border-radius: 0.375rem;
color: #842029;
}
/* die beiden Hauptoptionen 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 durch dangerouslySetInnerHTML:
ein Stil des globalen Stylesheets, wie alle anderen */
.captcha-image svg {
display: block;
border: 1px solid #dee2e6;
border-radius: 0.375rem;
}
|
Das Stylesheet der HTML-Anwendung, fast unverändert übernommen. Bemerkenswert ist nur der Fehlerbereich (Zeilen 24–35), der am unteren Fensterrand positioniert wird, wenn die Seite hoch ist.
10.4.3. Die Zugriffsschicht für die API
10.4.3.1. src/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; // Anzeigename: "Marie PELISSIER"
role: Role;
}
// GET /api/captcha
export interface Captcha {
id: string;
svg: string;
}
// eine Anrede, ein Vorname, ein Nachname
export interface Identity {
title: string;
firstName: string;
lastName: string;
}
// ein Arzt oder ein Client: GET /api/doctors, GET /api/clients/:id...
export interface Person extends Identity {
id: number;
version: number; // optimistische Sperre: mit einer Aktualisierung zurückzusenden
login?: string; // nur für den ADMIN
}
// was zum Erstellen / Aktualisieren einer Person gesendet wird (ADMIN)
export interface PersonData extends Identity {
login: string; // '' = Standardwert (Erstellung) oder unverändert (Aktualisierung)
password: string; // dito
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; // ausgefüllt, 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 JSON-Objekte der API, beschrieben im Kapitel „Der Server RdvMedecins: eine Blackbox“, übersetzt in [TypeScript]-Interfaces:
- Zeilen 25–29: eine Anrede, ein Vorname, ein Nachname – das, was Ärzte, Kunden und Patienten bei der Terminvergabe gemeinsam haben;
- Zeilen 32–36: ein Arzt oder ein Client. [version]: die optimistische Sperre des Servers; eine Änderung gibt die gelesene Version zurück: Hat jemand den Datensatz in der Zwischenzeit geändert, lehnt der Server ab ([ERRORS.CONCURRENT_UPDATE]);
- Zeilen 54–60: ein Kalendereintrag. Der Server gibt die RECHTE des angemeldeten Benutzers an: [bookable], [appointmentId] (ausgefüllt, wenn der Benutzer stornieren kann); der Client muss sie nicht neu berechnen;
- Zeile 67: ein Übersetzungsschlüssel für Patienten, die bereits einen Termin haben.
10.4.3.2. src/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
// (4xx- / 5xx-Antwort des Servers, Server nicht erreichbar, Antwort eines Proxys)
// wird zu einem ApiError, der den Übersetzungsschlüssel der Meldung, deren
// Parameter und den Fehler jedes Felds eines abgelehnten Formulars trägt.
// =========================================================================
export class ApiError extends Error {
readonly statusCode: number; // 0: Der Server hat nicht geantwortet
readonly key: string; // Übersetzungsschlüssel: 'ERRORS.LOGIN_TAKEN'
readonly params: Record<string, string>;
readonly fields: Record<string, string>; // Fehler jedes Felds
constructor(statusCode: number, key: string, params: Record<string, string> = {}, fields: Record<string, string> = {}) {
super(key);
this.name = 'ApiError';
this.statusCode = statusCode;
this.key = key;
this.params = params;
this.fields = fields;
}
}
// eine Fehlerantwort (4xx, 5xx) -> ein ApiError
export async function fromResponse(response: Response): Promise<ApiError> {
let body: { key?: string; params?: Record<string, string>; fields?: Record<string, string> } = {};
try {
const json: unknown = await response.json();
if (typeof json === 'object' && json !== null) {
body = json;
}
} catch {
// kein JSON: Es hat nicht unser Server geantwortet
}
return new ApiError(
response.status,
// kein Schlüssel: Es hat nicht unser Server geantwortet, sondern ein Proxy
// (Vite: 500 oder 502 ohne JSON-Body; nginx: 502, 504...)
body.key ?? (response.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR'),
body.params,
body.fields,
);
}
|
Die Klasse [ApiError] aus Beispiel 24, unverändert: JEDER Anfragefehler wird zu einem [ApiError], der den Übersetzungsschlüssel der Meldung, deren Parameter und den Fehler zu jedem Feld eines abgelehnten Formulars enthält.
10.4.3.3. src/api/client.ts
| // =========================================================================
// api/client.ts - ALLE Anfragen an die API laufen hier durch
// -------------------------------------------------------------------------
// Übernommen aus common/api.ts der Beispiele, mit einer neuen Funktion: der
// zentralen Behandlung der Antwort 401.
//
// Ein 401 kann jederzeit auftreten: Das Token ist abgelaufen (2 Stunden), das
// Konto wurde gelöscht, der Server wurde mit einem anderen geheimen
// Schlüssel neu gestartet... Statt diesen Fall in jeder Komponente zu behandeln,
// behandeln wir ihn HIER, einmalig. Diese Datei kennt aber weder den Router noch die
// Meldungen (sie hängt von nichts ab): Sie ruft eine Funktion auf, die ihr beim Start
// übergeben wurde (whenSessionExpired, siehe router.ts), die den
// Benutzer vergisst und zur Anmeldeseite weiterleitet.
//
// Einige Anfragen behandeln ihr 401 selbst (die Anmeldung, GET
// /api/auth/me...): Sie sind "öffentlich" (siehe rdvmedecins.api.ts).
// =========================================================================
import { fromResponse, ApiError } from './api-error';
// was zu tun ist, wenn der Server auf eine geschützte Anfrage mit 401 antwortet
let sessionExpired: () => void = () => {};
export function whenSessionExpired(action: () => void): void {
sessionExpired = action;
}
export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
// isPublic: true für die Routen, die ihr 401 selbst behandeln
export async function request<T>(method: Method, url: string, body?: unknown, isPublic = false): Promise<T> {
let response: Response;
try {
response = await fetch(`/api${url}`, {
method,
headers: body === undefined ? {} : { 'Content-Type': 'application/json' },
body: body === undefined ? undefined : JSON.stringify(body),
});
} catch {
// keine Antwort: Netzwerk ausgefallen, Server gestoppt
throw new ApiError(0, 'ERRORS.SERVER_UNREACHABLE');
}
if (!response.ok) {
const error = await fromResponse(response);
if (error.statusCode === 401 && !isPublic) {
sessionExpired();
}
throw error;
}
return (await response.json()) as T;
}
|
Die Funktion [request] aus Beispiel 24 mit einer Neuerung: der 401-Antwort.
- Zeilen 22–26: die Funktion, die aufgerufen wird, wenn eine geschützte Anfrage eine 401-Antwort erhält. Diese Datei hat keine Abhängigkeiten (weder vom Router noch von den Meldungen): [router.ts] weist ihr diese Funktion beim Start zu. So wird eine zirkuläre Abhängigkeit vermieden (der Client importiert den Router, der die Routen importiert, die die Seiten importieren, die den Client importieren ...);
- Zeile 31: Manche Anfragen behandeln ihre 401-Fehler selbst: die Anmeldung (falsches Passwort: 401), [GET /api/auth/me] (niemand ist angemeldet: 401) ...;
- Zeilen 45–47: Eine geschützte Anfrage erhält eine 401: Die Sitzung ist abgelaufen. Das wird gemeldet, DANN wird das Promise wie bei jedem anderen Fehler abgelehnt: Die Komponente, die auf die Antwort wartet, muss keine besondere Aktion ausführen.
10.4.3.4. src/api/rdvmedecins.api.ts
| // =========================================================================
// api/rdvmedecins.api.ts - eine Funktion pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients: Die Komponenten rufen diese
// typisierten Funktionen auf, ohne etwas über URLs, fetch oder JSON zu wissen. Wenn
// sich die API ändert, ändert sich nur diese Datei.
// Jede Funktion gibt ein PROMISE zurück: Die Komponenten verketten die
// Anfragen mit async / await. Bei einem Fehler wird das Promise mit
// einem ApiError abgelehnt (siehe client.ts).
// =========================================================================
import { request } from './client';
import type {
Schedule,
Captcha,
PersonData,
Registration,
MyAccountUpdate,
MyAccount,
MyArea,
Person,
User,
} from './types';
// /api/doctors oder /api/clients: beide werden auf die gleiche Weise verwaltet
export type PersonType = 'doctors' | 'clients';
type Empty = Record<string, never>;
export const api = {
// ------------------------------------------------ Anmeldung (öffentliche Routen)
captcha: () => request<Captcha>('GET', '/captcha', undefined, true),
me: () => request<User>('GET', '/auth/me', undefined, true),
logIn: (login: string, password: string, captchaId: string, captcha: string) =>
request<User>('POST', '/auth/login', { login, password, captchaId, captcha }, true),
logOut: () => request<Empty>('POST', '/auth/logout', {}, true),
// ------------------------------------------------ Kontoerstellung (öffentlich)
registrationAccess: (captchaId: string, captcha: string) =>
request<Empty>('POST', '/register/access', { captchaId, captcha }, true),
registrationAccessStatus: () => request<{ valid: boolean }>('GET', '/register/access', undefined, true),
register: (data: Registration) => request<{ login: string }>('POST', '/register', data, true),
// ------------------------------------------------ Terminkalender und Termine
// doctorId null: für einen angemeldeten Arzt SEIN Terminkalender
schedule(doctorId: number | null, day: string) {
const params = new URLSearchParams({ day });
if (doctorId !== null) {
params.set('doctorId', String(doctorId));
}
return request<Schedule>('GET', `/schedule?${params}`);
},
book: (day: string, slotId: number, clientId: number | null) =>
request<{ id: number }>('POST', '/appointments', { day, slotId, clientId: clientId ?? undefined }),
cancelAppointment: (appointmentId: number) => request<Empty>('DELETE', `/appointments/${appointmentId}`),
// ------------------------------------------------ Ärzte und Clients
list: (type: PersonType) => request<Person[]>('GET', `/${type}`),
read: (type: PersonType, id: number) => request<Person>('GET', `/${type}/${id}`),
add: (type: PersonType, data: PersonData) => request<Person>('POST', `/${type}`, data),
edit: (type: PersonType, id: number, data: PersonData) => request<Person>('PUT', `/${type}/${id}`, data),
remove: (type: PersonType, id: number) => request<Empty>('DELETE', `/${type}/${id}`),
// ------------------------------------------------ Bereich des Patienten
myArea: () => request<MyArea>('GET', '/my-area'),
myAccount: () => request<MyAccount>('GET', '/my-account'),
editMyAccount: (data: MyAccountUpdate) => request<User>('PUT', '/my-account', data),
deleteMyAccount: (currentPassword: string) => request<Empty>('DELETE', '/my-account', { currentPassword }),
};
|
Eine typisierte Funktion pro Route der API: Die Komponenten rufen [api.schedule(1, '2026-10-05')] auf, ohne etwas über URL oder JSON zu wissen. Ändert sich die API, ändert sich nur diese Datei.
- Zeilen 32–36: die Anmelderouten, die öffentlich sind (letzter Parameter von [request]: [true]);
- Zeilen 39–42: die Kontoerstellung in zwei Schritten: Das Lösen des CAPTCHA auf der Anmeldeseite liefert einen „Pass“ (ein Cookie), den die Route [POST /api/register] verlangt;
- Zeilen 46–52: [URLSearchParams] erzeugt die Parameter der Adresse (und kodiert sie). Für einen angemeldeten Arzt gibt es keine [doctorId]: Der Server liefert SEINEN Terminkalender;
- Zeile 54: Ein Patient bucht für sich selbst: keine [clientId]. [JSON.stringify] lässt die Eigenschaften mit dem Wert [undefined] weg;
- Zeilen 58–62: Ärzte und Clients werden gleich behandelt: Der Typ ist ein Parameter;
- Zeile 28: der Typ eines leeren Objekts [{}], das bestimmte Routen zurückgeben.
10.4.4. Sprachen
10.4.4.1. src/i18n/i18n.ts
| // =========================================================================
// i18n/i18n.ts - Französisch und Englisch (i18next, 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 i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import fr from './fr.json';
import en from './en.json';
export type Language = 'fr' | 'en';
export const LANGUAGES: Language[] = ['fr', 'en'];
const STORAGE_KEY = 'rdvmedecins.language';
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';
}
// bei jedem Sprachwechsel: speichern und das Attribut
// lang der Seite aktualisieren (Screenreader, Rechtschreibprüfung, Silbentrennung)
i18n.on('languageChanged', (language) => {
document.documentElement.lang = language;
try {
localStorage.setItem(STORAGE_KEY, language);
} catch {
// unwichtig
}
});
i18n.use(initReactI18next).init({
// die Wörterbücher sind Teil des Codes der Anwendung: keine Anfrage
resources: { fr: { translation: fr }, en: { translation: en } },
lng: initialLanguage(),
fallbackLng: 'en',
interpolation: { escapeValue: false }, // React maskiert bereits alles
});
export default i18n;
|
Die Konfiguration aus Beispiel 21:
- Zeilen 22–32: die gespeicherte Sprache, andernfalls die Sprache des Browsers. Der Zugriff auf [localStorage] kann fehlschlagen (striktes privates Surfen): [try / catch];
- Zeilen 36–43: Bei jedem Sprachwechsel wird die Sprache gespeichert und das Attribut [lang] der Seite aktualisiert;
- Zeile 47: Die Wörterbücher, als Module importiert, sind Teil des kompilierten Codes und erfordern keine zusätzlichen Anfragen;
- Zeile 50: [React] maskiert bereits alles, was es anzeigt: Es ist nicht nötig, das doppelt zu tun.
Es gibt kein Gegenstück zur „Title-Strategie“ von [Angular]: Jede Seite deklariert ihren Titel mit dem Tag [<title>], das [React] 19 im Kopfbereich des Dokuments platziert (siehe [components/PageTitle.tsx]).
10.4.4.2. Wörterbücher
Die Wörterbücher [fr.json] und [en.json] sind die der HTML-Anwendung aus dem Kurs [NestJS], ergänzt um einige clientspezifische Schlüssel ([ERRORS.SERVER_UNREACHABLE] ...). Ihre Parametersyntax [{{min}}] ist exakt dieselbe wie die von [i18next]. 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 Stores
10.4.5.1. src/stores/session.ts
| // =========================================================================
// stores/session.ts - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der angemeldete Benutzer (oder null) in einem Zustand-Store (Zustand, siehe Beispiel
// 20): lesbar für die Komponenten (useSession) UND für Code, der
// keine Komponente ist (die Guards des Routers: useSession.getState()).
//
// Das JWT-Token selbst ist NICHT hier: Es liegt in einem httpOnly-Cookie, das
// nur der Browser verwaltet. Der Store behält nur die BESCHREIBUNG des
// Benutzers, die der Server zurückgibt ({ login, name, role }).
//
// Beim Start (und nach einem F5) ist der Store leer: check() fragt
// den Server, nur einmal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================
import { create } from 'zustand';
import { api } from '../api/rdvmedecins.api';
import type { Role, User } from '../api/types';
interface Session {
user: User | null;
check: () => Promise<void>;
logIn: (login: string, password: string, captchaId: string, captcha: string) => Promise<void>;
update: (u: User) => void;
logOut: () => Promise<void>;
forget: () => void;
}
// wurde dem Server die Frage "Wer ist angemeldet?" bereits gestellt?
// (eine Modulvariable: sie muss nicht angezeigt werden)
let checking: Promise<void> | null = null;
export const useSession = create<Session>()((set, get) => ({
user: null,
// wird vom Guard des Routers vor JEDER Navigation aufgerufen; fragt nur beim ersten
// Mal den Server (das Promise wird behalten und wiederverwendet)
check() {
checking ??= api
.me()
.then((u) => set({ user: u }))
.catch(() => set({ user: null })); // 401: niemand; oder Server nicht erreichbar
return checking;
},
async logIn(login, password, captchaId, captcha) {
set({ user: await api.logIn(login, password, captchaId, captcha) });
},
// der Benutzer hat seinen Namen oder seine Anmeldung geändert (PUT /api/my-account)
update: (u) => set({ user: u }),
async logOut() {
try {
await api.logOut();
} finally {
get().forget();
}
},
// ohne den Server etwas zu fragen: Sitzung abgelaufen, Konto gelöscht
forget: () => set({ user: null }),
}));
// was sich aus dem Benutzer ableiten lässt: gewöhnliche Funktionen
export const role = (u: User | null): Role | null => u?.role ?? null;
export const isAdmin = (u: User | null) => role(u) === 'ADMIN';
export const isPatient = (u: User | null) => role(u) === 'USER';
// ADMIN und DOCTOR: Termine beliebiger Patienten buchen und stornieren
export const isManager = (u: User | null) => role(u) === 'ADMIN' || role(u) === 'DOCTOR';
// die Startseite jeder Rolle, direkt nach der Anmeldung
export const homePage = (u: User | null) => (isPatient(u) ? '/my-area' : '/schedule');
|
Der angemeldete Benutzer in einem Store von [Zustand] (Beispiel 20). Ein Store kann von den Komponenten gelesen werden ([useSession((s) => s.user)]) UND über Code, der keine Komponente ist: [useSession.getState()] (die Router-Guards).
- Zeile 21: die BESCHREIBUNG des Benutzers ([{ login, name, role }]). Das JWT-Token befindet sich dagegen im httpOnly-Cookie: Der Client sieht es nie;
- Zeilen 31–44: [check()] fragt den Server NUR EINMAL, wer angemeldet ist: Das Promise wird aufbewahrt und wiederverwendet ([??=]: Zuweisung, wenn die Variable [null] ist). Die Guards rufen es vor jeder Navigation auf: Nur der erste wartet tatsächlich;
- Zeilen 46–48: die Anmeldung: Der vom Server zurückgegebene Benutzer wird im Store gespeichert;
- Zeilen 53–59: die Abmeldung. [finally]: Auch wenn der Server nicht antwortet, vergisst der Client den Benutzer;
- Zeilen 66–72: was sich über den Benutzer ableiten lässt: gewöhnliche Funktionen, die den Benutzer als Parameter erhalten. Eine Komponente schreibt [isAdmin(user)] nach dem Lesen von [user] aus dem Store; sie wird neu angezeigt, wenn sich der Benutzer ändert.
10.4.5.2. src/stores/messages.ts
| // =========================================================================
// stores/messages.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"-Panel).
// Eine Meldung ist ein Übersetzungsschlü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 Navigation
// danach. Der Router ruft newPage() am Ende jeder
// Navigation auf (siehe router.ts). Das war serverseitig die Aufgabe des
// kurzlebigen Cookies "rdvmedecins_flash".
// =========================================================================
import { create } from 'zustand';
import { ApiError } from '../api/api-error';
export interface Message {
key: string;
params?: Record<string, string>;
}
interface Messages {
success: Message | null;
error: Message | null;
// die auf der nächsten Seite anzuzeigenden Meldungen
pending: { success: Message | null; error: Message | null } | null;
showSuccess: (key: string, params?: Record<string, string>) => void;
showError: (key: string, params?: Record<string, string>) => void;
showApiError: (e: unknown) => void;
clear: () => void;
flash: (type: 'success' | 'error', key: string, params?: Record<string, string>) => void;
newPage: () => void;
}
export const useMessages = create<Messages>()((set) => ({
success: null,
error: null,
pending: null,
showSuccess: (key, params) => set({ success: { key, params }, error: null }),
showError: (key, params) => set({ error: { key, params }, success: null }),
// ein ApiError -> die Meldung der Seite; jeder andere Fehler ist ein
// Fehler des Clients, der durchgelassen wird (Browserkonsole)
showApiError(e) {
if (!(e instanceof ApiError)) {
throw e;
}
set({ error: { key: e.key, params: e.params }, success: null });
},
clear: () => set({ success: null, error: null }),
// für die NÄCHSTE Seite
flash: (type, key, params) =>
set((m) => ({ pending: { success: null, error: null, ...m.pending, [type]: { key, params } } })),
// eine neue Seite: Die Meldungen der vorherigen verschwinden, die
// Flash-Meldungen erscheinen
newPage: () =>
set((m) => ({ success: m.pending?.success ?? null, error: m.pending?.error ?? null, pending: null })),
}));
|
Dem Benutzer angezeigte Meldungen: eine Erfolgsmeldung oben auf der Seite, eine Fehlermeldung unten.
- Zeilen 21–24: Eine Meldung ist ein Übersetzungsschlüssel mit seinen Parametern, kein Klartext: Sie übersetzt sich automatisch neu, wenn der Benutzer die Sprache wechselt;
- Zeilen 49–54: Ein [ApiError] wird zur Fehlermeldung der Seite. Jeder andere Fehler ist ein clientseitiges Problem (ein Programmierfehler): Er wird erneut ausgelöst, damit er in der Browserkonsole erscheint;
- Zeilen 59–60: [flash] legt eine Meldung für die NÄCHSTE Seite fest. Eine Aktion, die mit einem Seitenwechsel endet (einen Arzt hinzufügen, gefolgt von der Rückkehr zur Liste), verwendet dies: Eine sofort angezeigte Meldung würde beim Navigieren des Benutzers verschwinden;
- Zeilen 64–65: wird vom Router am Ende jeder Navigation aufgerufen: Die ausstehenden Meldungen werden zu den Meldungen der Seite.
10.4.5.3. src/stores/confirmation.ts
| // =========================================================================
// stores/confirmation.ts - "Sind Sie sicher?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 16, in Form eines Stores: confirm(key) öffnet
// den Bestätigungsdialog (components/ConfirmDialog.tsx, einmal
// im Layout platziert) und gibt ein Promise zurück, das mit true (Ja) oder
// false (Nein) aufgelöst wird. Die Meldung ist ein Übersetzungsschlüssel: Der Dialog übersetzt ihn
// in die aktuelle Sprache.
//
// if (await confirm('SCHEDULE.CANCEL_CONFIRM')) { ... }
// =========================================================================
import { create } from 'zustand';
import { useMessages } from './messages';
interface Confirmation {
messageKey: string | null; // null: Dialog geschlossen
answer: (yes: boolean) => void;
}
// die Funktion, die das aktuelle Promise auflöst (nichts anzuzeigen: außerhalb des Zustands)
let respond: ((yes: boolean) => void) | null = null;
export const useConfirmation = create<Confirmation>()((set) => ({
messageKey: null,
answer(yes) {
set({ messageKey: null });
const r = respond;
respond = null;
r?.(yes);
},
}));
// eine gewöhnliche Funktion, überall verwendbar
export function confirm(key: string): Promise<boolean> {
respond?.(false); // eine noch offene Frage? Sie zählt als "Nein"
// eine neue Frage: Die Meldungen der vorherigen Aktion sind veraltet
useMessages.getState().clear();
useConfirmation.setState({ messageKey: key });
return new Promise<boolean>((resolve) => {
respond = resolve;
});
}
|
Das Bestätigungsfenster aus Beispiel 16, implementiert als Store und gewöhnliche Funktion:
- Zeile 17: die gestellte Frage (ein Übersetzungsschlüssel) oder [null]: Das Fenster ([components/ConfirmDialog.tsx]) ist geschlossen;
- Zeile 22: die Funktion, die das Promise für die aktuelle Frage auflöst. Nichts anzuzeigen: Das ist kein Zustand, sondern eine Modulvariable;
- Zeilen 35–43: [confirm] öffnet das Fenster und gibt ein Promise zurück, das von [answer] mit [true] (Ja) oder [false] (Nein) aufgelöst wird. Eine Seite schreibt einfach [if (await confirm('SCHEDULE.CANCEL_CONFIRM')) { ... }]. Ein Kontext ist nicht nötig, wie in Beispiel 16: Der Store ist überall zugänglich.
10.4.6. Die Hooks
| // =========================================================================
// hooks/useFormSubmit.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 nur an EINER Stelle, dem Server), und wenn das Formular abgelehnt wird:
// - Der Fehler jedes Felds (ApiError.fields) wird unter dem
// Feld angezeigt, rot umrandet;
// - die allgemeine Meldung (ApiError.key) wird unten auf der Seite angezeigt.
// Dieser Hook fasst diese Schritte zusammen. Eine Seite ruft ihn einmal pro Formular auf:
//
// const submission = useFormSubmit();
// if (await submission.submit(() => api.register(form))) { ... }
// <InputField ... error={submission.errors.lastName} />
// =========================================================================
import { useCallback, useState } from 'react';
import { ApiError } from '../api/api-error';
import { useMessages } from '../stores/messages';
export function useFormSubmit() {
const showApiError = useMessages((m) => m.showApiError);
// der Fehler jedes Felds: ein Übersetzungsschlüssel
const [errors, setErrors] = useState<Record<string, string>>({});
// die Parameter der Fehlermeldungen ({min}...), vom Server zurückgegeben
const [params, setParams] = useState<Record<string, string>>({});
const [submitting, setSubmitting] = useState(false);
// führt das Senden aus; gibt true zurück, wenn es erfolgreich war. Bei einem ApiError werden die
// Fehler angezeigt und false wird zurückgegeben.
const submit = useCallback(
async (action: () => Promise<unknown>): Promise<boolean> => {
setErrors({});
setParams({});
setSubmitting(true);
try {
await action();
return true;
} catch (e) {
showApiError(e); // (wirft jeden Fehler, der kein ApiError ist, erneut)
const error = e as ApiError;
setErrors(error.fields);
setParams(error.params);
return false;
} finally {
setSubmitting(false);
}
},
[showApiError],
);
// der Benutzer ändert ein Feld: Sein Fehler verschwindet
const clearError = useCallback((field: string) => {
setErrors((e) => {
if (!(field in e)) return e; // nichts zu löschen: dasselbe Objekt (kein neues Rendering)
const { [field]: _cleared, ...rest } = e;
return rest;
});
}, []);
return { errors, params, submitting, submit, clearError };
}
|
Alle Formulare der Anwendung folgen dem in Beispiel 25 gezeigten Muster: Im Browser werden keine Validierungsregeln geprüft, und wenn der Server die Übermittlung ablehnt, wird der Fehler zu jedem Feld unter dem Feld angezeigt, mit einer allgemeinen Fehlermeldung am Seitenende. Dieser benutzerdefinierte Hook (Beispiel 15) übernimmt Folgendes:
- Zeilen 24–27: sein Zustand: der Fehler zu jedem Feld (ein Übersetzungsschlüssel), deren Parameter und „submitting“ (um die Schaltfläche zu deaktivieren);
- Zeilen 31–50: [submit(action)] führt die Übermittlung aus und gibt [true] zurück, wenn sie gelingt. Wird [ApiError] zurückgegeben, werden die Fehler angezeigt, und die Funktion gibt [false] zurück. [useCallback]: Die Funktion bleibt von einer Anzeige zur nächsten DIESELBE;
- Zeilen 53–59: Der Benutzer ändert ein Feld: Der Fehler verschwindet. Hatte das Feld keinen Fehler, wird DASSELBE Objekt zurückgegeben; [React] zeigt dann nichts neu an. [const { [field]: _cleared, ...rest } = e]: [rest] ist eine Kopie von [e] ohne die Eigenschaft [field].
10.4.6.2. src/hooks/useCaptcha.ts
| // =========================================================================
// hooks/useCaptcha.ts - ein CAPTCHA-Bild und die Möglichkeit, es zu wechseln
// -------------------------------------------------------------------------
// Lädt ein CAPTCHA (GET /api/captcha), wenn die Komponente, die es verwendet,
// angezeigt wird. reload() fordert ein anderes an: Das ist nach JEDEM
// Versuch nötig, weil ein Bild nur EINMAL verwendet werden kann (der Server vergisst es, sobald
// er es geprüft hat). Die Anmeldeseite verwendet es mit der Komponente
// CaptchaField, die das Bild und das Eingabefeld anzeigt.
// =========================================================================
import { useCallback, useEffect, useState } from 'react';
import { api } from '../api/rdvmedecins.api';
import type { Captcha } from '../api/types';
export function useCaptcha() {
const [captcha, setCaptcha] = useState<Captcha | null>(null);
const reload = useCallback(async () => {
try {
setCaptcha(await api.captcha());
} catch {
setCaptcha(null); // Server nicht erreichbar: Die Anmeldung schlägt mit einer klaren Meldung fehl
}
}, []);
useEffect(() => {
reload();
}, [reload]);
// captchaId: der Bezeichner des angezeigten Bildes, mit der Antwort zu senden
return { svg: captcha?.svg ?? '', captchaId: captcha?.id ?? '', reload };
}
|
Ein CAPTCHA-Bild, das beim Anzeigen der Komponente geladen wird, und [reload()], um ein anderes anzufordern: Das ist nach JEDEM Versuch nötig, weil der Server ein Bild verwirft, sobald er es geprüft hat.
| // =========================================================================
// 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 (siehe Beispiel 09).
// =========================================================================
import type { 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)}`;
}
// das heutige Datum im Format "yyyy-MM-dd" (das von <input type="date"> und 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): 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 ist Sache des Clients (Beispiel 09). Dies sind gewöhnliche Funktionen: [React] verlangt keine „Pipes“, und ein Ausdruck wie JSX kann jede Funktion aufrufen ([{timeRange(c)}]).
- Zeilen 33–39: [day is string]: ein Typprädikat: Gibt die Funktion [true] zurück, [TypeScript] weiß dann, dass [day] eine Zeichenkette ist. Ein Datum, „das existiert“: [2026-02-30] hat das richtige Format, aber [new Date] wandelt es in den 2. März um; das resultierende Datum wird dann mit der ursprünglichen Zeichenkette verglichen;
- Zeilen 42–47: der ausgeschriebene Tag in der Sprache des Benutzers mithilfe von [Intl.DateTimeFormat]. [timeZone: 'UTC']: Das Datum wird um Mitternacht (UTC) erstellt; in der Zeitzone von Martinique (UTC-4) formatiert, wäre es noch der Vortag.
10.4.8. Der Router
10.4.8.1. src/routes.tsx
| // =========================================================================
// routes.tsx - die Seiten der Anwendung und ihre Zugriffsrechte
// -------------------------------------------------------------------------
// Dieselben 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 (Vite tut das in der Entwicklung; in der Produktion
// siehe web/client-spa.ts des JSON-Servers).
//
// Alle Seiten sind KINDER der Wurzelroute, deren Komponente
// Layout sie in ihrem <Outlet /> anzeigt. Die Funktion page() beschreibt eine
// Seite: ihre Adresse, ihre Komponente (bei Bedarf geladen für die Seiten,
// die nicht immer besucht werden) und den Guard, der ihre Rechte prüft.
// =========================================================================
import type { ComponentType } from 'react';
import { redirect, type MiddlewareFunction, type RouteObject } from 'react-router';
import type { PersonType } from './api/rdvmedecins.api';
import { guard, registrationGuard, type Rights } from './guards';
import Layout from './components/Layout';
import Login from './pages/Login';
import Schedule from './pages/Schedule';
import ErrorPage from './pages/ErrorPage';
// eine Seite: sofort geladene Komponente (Component) oder bei Bedarf geladene
// (load); otherGuards: seitenspezifische Guards, nach dem gemeinsamen Guard
interface Page {
path: string;
rights: Rights;
Component?: ComponentType;
load?: () => Promise<ComponentType>;
otherGuards?: MiddlewareFunction[];
}
function page({ path, rights, Component, load, otherGuards = [] }: Page): RouteObject {
return {
path,
// die Guards laufen VOR dem Laden der Seite
middleware: [guard(rights), ...otherGuards],
...(load ? { lazy: async () => ({ Component: await load() }) } : { Component }),
};
}
// die Verwaltungsseiten der Ärzte UND der Clients (ADMIN), nach demselben
// Muster; die Komponente erhält den Typ als Prop
function personPages(type: PersonType): RouteObject[] {
const rights: Rights = { roles: ['ADMIN'] };
const list = async () => {
const { default: Persons } = await import('./pages/Persons');
return () => <Persons type={type} />;
};
const form = async () => {
const { default: PersonForm } = await import('./pages/PersonForm');
return () => <PersonForm type={type} />;
};
return [
page({ path: type, rights, load: list }),
page({ path: `${type}/add`, rights, load: form }),
page({ path: `${type}/:id/edit`, rights, load: form }),
];
}
export const routes: RouteObject[] = [
{
path: '/',
Component: Layout,
// wird bei der allerersten Navigation angezeigt (während der
// Server gefragt wird, wer angemeldet ist)
HydrateFallback: () => null,
children: [
// "/": nach /login, das seinerseits zur Startseite der Rolle weiterleitet, wenn der Benutzer angemeldet ist
// (eine Komponente, die nichts anzeigt: Die Weiterleitung erfolgt vorher)
{ index: true, loader: () => redirect('/login'), Component: () => null },
page({ path: 'login', rights: { public: true }, Component: Login }),
page({ path: 'schedule', rights: {}, Component: Schedule }),
...personPages('doctors'),
...personPages('clients'),
page({
path: 'register',
rights: { public: true },
load: async () => (await import('./pages/Register')).default,
otherGuards: [registrationGuard],
}),
page({ path: 'my-area', rights: { roles: ['USER'] }, load: async () => (await import('./pages/PatientArea')).default }),
page({ path: 'my-account', rights: { roles: ['USER'] }, load: async () => (await import('./pages/MyAccount')).default }),
page({ path: 'forbidden', rights: {}, Component: () => <ErrorPage code={403} /> }),
page({ path: '*', rights: { public: true }, Component: () => <ErrorPage code={404} /> }),
],
},
];
|
Dieselben Adressen wie in der HTML-Anwendung, aber jetzt sind es Routen des CLIENTS:
- Zeilen 31–37: die Beschreibung einer Seite: ihre Adresse, ihre Zugriffsrechte und ihre Komponente, die entweder sofort bereitgestellt wird ([Component]) oder bei Bedarf geladen wird ([load]);
- Zeilen 39–46: [page()] erzeugt die entsprechende Route:
- Zeile 43: der gemeinsame Guard, erzeugt anhand der Berechtigungen der Seite, gefolgt von den seitenspezifischen Guards. Sie laufen VOR dem Laden der Seite (Beispiel 18);
- Zeile 44: [lazy]: Der Code der Seite wird beim ersten Besuch geladen (Beispiel 17). Die Anmeldeseite und der Terminkalender, die jeder sehen kann, werden sofort geladen; die ADMIN- und Patientenseiten werden bei Bedarf geladen;
- Zeilen 50–65: die drei Seiten zur Verwaltung von Ärzten und anschließend von Clients, die dasselbe Template verwenden. Die Komponente wird in eine parameterlose Komponente eingehüllt, [() => <Persons type={type} />]: So erhält sie den Typ als Prop;
- Zeilen 69–70: die Wurzelroute. Ihre Komponente [Layout] zeigt die aktuelle Seite in ihrem [<Outlet />] an;
- Zeile 73: was während der allerersten Navigation angezeigt wird, während der Guard den Server fragt, wer angemeldet ist: nichts;
- Zeile 77: Die Adresse [/] leitet zu [/login] um, dessen Guard seinerseits zur Startseite der Rolle umleitet, wenn der Benutzer angemeldet ist;
- Zeilen 78–79: [rights: { public: true }]: Die Seite ist ohne Anmeldung zugänglich; [rights: {}]: Sie müssen angemeldet sein, unabhängig von Ihrer Rolle;
- Zeilen 83–87: Das Erstellen eines öffentlichen Kontos hat einen zweiten Guard, [registrationGuard];
- Zeilen 88–89: [roles: ['USER']]: die Seiten des Patienten;
- Zeile 90: die 403-Seite;
- Zeile 91: die 404-Seite: [*] bezeichnet jede Adresse, die keine andere Route erkennt.
Zur Erinnerung: Lädt der Benutzer [/schedule] (F5) neu, fordert der Browser tatsächlich [/schedule] vom Server an, der dann [index.html] zurückgeben muss: Das leistet der Entwicklungsserver von [Vite], und in der Produktion der JSON-Server (siehe Kapitel „Bereitstellung“).
10.4.8.2. src/guards.ts
| // =========================================================================
// guards.ts - die Guards des Routers (Middlewares, siehe Beispiel 18)
// -------------------------------------------------------------------------
// guard(rights) ERZEUGT den Guard einer Seite aus ihren Zugriffsrechten:
// - public : ohne Anmeldung zugänglich;
// - roles : die erlaubten Rollen (fehlt = alle angemeldeten Rollen).
// Jede Seite deklariert ihre eigenen (siehe routes.tsx). Vor jeder Navigation
// zu dieser Seite
// 1. fragt der Guard beim ersten Mal (Start, F5) den Server, wer
// angemeldet ist (useSession.getState().check());
// 2. prüft er die Rechte der Seite und leitet bei Bedarf weiter.
//
// 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 das Token und die Rolle erneut prüft.
// =========================================================================
import { redirect, type MiddlewareFunction } from 'react-router';
import type { Role } from './api/types';
import { api } from './api/rdvmedecins.api';
import { homePage, useSession } from './stores/session';
import { useMessages } from './stores/messages';
export interface Rights {
public?: boolean;
roles?: Role[];
}
export function guard(rights: Rights): MiddlewareFunction {
return async ({ request }) => {
await useSession.getState().check();
// getState(): der Zustand des Stores, außerhalb einer Komponente gelesen
const user = useSession.getState().user;
const url = new URL(request.url);
if (rights.public) {
// bereits angemeldet: Die Anmeldeseite ergibt keinen Sinn mehr
if (url.pathname === '/login' && user !== null) {
throw redirect(homePage(user));
}
return;
}
if (user === null) {
// die angeforderte Seite wird gemerkt, um nach der Anmeldung dorthin zurückzukehren
throw redirect(`/login?redirect=${encodeURIComponent(url.pathname + url.search)}`);
}
if (rights.roles && !rights.roles.includes(user.role)) {
throw redirect('/forbidden');
}
};
}
// ein für die Route /register SPEZIFISCHER Guard: Ohne Pass (auf der Anmeldeseite gelöstes
// CAPTCHA) zurück zur Anmeldeseite
export const registrationGuard: MiddlewareFunction = async () => {
const { valid } = await api.registrationAccessStatus().catch(() => ({ valid: false }));
if (!valid) {
useMessages.getState().flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
throw redirect('/login');
}
};
|
- Zeilen 24–27: die Zugriffsrechte einer Seite;
- Zeilen 29–51: [guard(rights)] ERZEUGT einen Guard, also eine Router-Middleware (Beispiel 18):
- Zeile 31: Beim ersten Mal (Start, F5) wird der Server gefragt, wer angemeldet ist; bei späteren Aufrufen liegt die Antwort bereits vor;
- Zeilen 36–42: eine öffentliche Seite. Ein angemeldeter Benutzer hat auf der Anmeldeseite nichts mehr zu tun: Er wird zu seiner Startseite umgeleitet;
- Zeilen 43–46: Niemand ist angemeldet: Umleitung zur Anmeldeseite, wobei die angeforderte Seite beibehalten wird ([?redirect=...]), um nach der Anmeldung zu ihr zurückzukehren;
- Zeilen 47–49: Die Rolle ist nicht berechtigt: die 403-Seite;
- [throw redirect(...)]: Ein Guard „löst“ eine Umleitung „aus“: Die aktuelle Navigation wird zugunsten der neuen Adresse abgebrochen;
- Zeilen 55–61: der Guard speziell für die Seite [/register]: Ohne Pass (das auf der Anmeldeseite gelöste CAPTCHA) zurück zur Anmeldeseite mit einer Meldung. Der Server würde die Kontoerstellung ohnehin verweigern.
Diese Prüfungen dienen lediglich dem KOMFORT: Es soll keine nutzlose Seite angezeigt werden. Der Schutz der Daten wird vom Server gewährleistet, der Token und Rolle bei JEDER Anfrage erneut prüft.
10.4.9. Die Komponenten
10.4.9.1. src/components/Layout.tsx
| // =========================================================================
// components/Layout.tsx - das LAYOUT, das allen Seiten gemeinsam ist
// -------------------------------------------------------------------------
// Die Komponente der Wurzelroute (siehe routes.tsx), das Äquivalent zu
// views/layout.hbs der HTML-Anwendung:
// - die Navigationsleiste;
// - eine Erfolgsmeldung OBEN;
// - die aktuelle Seite (<Outlet />);
// - das Fehlerpanel UNTEN;
// - der Bestätigungsdialog, einmal für die ganze Anwendung.
// =========================================================================
import { Outlet } from 'react-router';
import NavBar from './NavBar';
import SuccessMessage from './SuccessMessage';
import ErrorPanel from './ErrorPanel';
import ConfirmDialog from './ConfirmDialog';
export default function Layout() {
return (
<>
<div className="container py-4">
<NavBar />
<SuccessMessage />
<Outlet />
<ErrorPanel />
</div>
<ConfirmDialog />
</>
);
}
|
Die Komponente der Wurzelroute, das Gegenstück zu [views/layout.hbs] in der HTML-Anwendung: die Navigationsleiste, die Erfolgsmeldung oben, die aktuelle Seite ([<Outlet />]) und der Fehlerbereich unten. Das Bestätigungsfenster wird dort einmal für die gesamte Anwendung platziert.
10.4.9.2. src/components/PageTitle.tsx
| // =========================================================================
// components/PageTitle.tsx - der Titel des Tabs, übersetzt
// -------------------------------------------------------------------------
// React 19 platziert jedes von einer Komponente gerenderte <title>-Element im <head> der Seite
// (siehe Beispiel 17). Jede Seite zeigt <PageTitle titleKey="..." />
// mit dem Schlüssel ihres Titels an: Der Tab zeigt "Schedule - RdvMedecins" und
// wird bei einem Sprachwechsel neu übersetzt.
// =========================================================================
import { useTranslation } from 'react-i18next';
export default function PageTitle({ titleKey }: { titleKey: string }) {
const { t } = useTranslation();
return <title>{`${t(titleKey)} - ${t('APP.TITLE')}`}</title>;
}
|
[React] 19 platziert jedes von einer Komponente gerenderte [<title>]-Element im Seitenkopf ([<head>]) (Beispiel 17). Jede Seite zeigt [<PageTitle titleKey="SCHEDULE.PAGE_TITLE" />] an: Der Tab zeigt „Terminkalender - RdvMedecins“ und wird bei einem Sprachwechsel neu übersetzt.
10.4.9.3. src/components/NavBar.tsx
| // =========================================================================
// components/NavBar.tsx - die Navigationsleiste
// -------------------------------------------------------------------------
// Gleicher Inhalt wie die 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 einfache
// Anzeigeerleichterung, der eigentliche Schutz liegt beim Server.
// =========================================================================
import { NavLink, useNavigate } from 'react-router';
import { useTranslation } from 'react-i18next';
import { LANGUAGES } from '../i18n/i18n';
import { isAdmin, isPatient, useSession } from '../stores/session';
export default function NavBar() {
const { t, i18n } = useTranslation();
const user = useSession((s) => s.user);
const logOut = useSession((s) => s.logOut);
const navigate = useNavigate();
async function onLogOut() {
await logOut().catch(() => {}); // auch wenn der Server nicht antwortet
navigate('/login');
}
return (
<nav className="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
<span className="navbar-brand mb-0">{t('APP.TITLE')}</span>
{user ? (
<ul className="navbar-nav me-auto">
{isPatient(user) && (
<li className="nav-item">
{/* NavLink setzt die Klasse "active" (Bootstrap) auf das Menü der angezeigten Seite */}
<NavLink className="nav-link" to="/my-area">{t('APP.MENU_MY_AREA')}</NavLink>
</li>
)}
<li className="nav-item">
<NavLink className="nav-link" to="/schedule">{t('APP.MENU_SCHEDULE')}</NavLink>
</li>
{isAdmin(user) && (
<>
<li className="nav-item">
<NavLink className="nav-link" to="/doctors">{t('APP.MENU_DOCTORS')}</NavLink>
</li>
<li className="nav-item">
<NavLink className="nav-link" to="/clients">{t('APP.MENU_PATIENTS')}</NavLink>
</li>
</>
)}
</ul>
) : (
<div className="me-auto"></div>
)}
<div className="d-flex align-items-center gap-2">
{/* FR / EN: keine Anfrage an den Server, die Seite wird an Ort und Stelle neu übersetzt */}
<div className="btn-group btn-group-sm" role="group" aria-label={t('APP.LANGUAGE')}>
{LANGUAGES.map((l) => (
<button key={l} type="button" className={`btn ${i18n.language === l ? 'btn-light' : 'btn-outline-light'}`}
aria-pressed={i18n.language === l} onClick={() => i18n.changeLanguage(l)}>
{l.toUpperCase()}
</button>
))}
</div>
{user && (
<>
<span className="badge text-bg-light text-primary">{user.role}</span>
<span className="text-white">{user.name}</span>
<button type="button" className="btn btn-sm btn-outline-light" onClick={onLogOut}>{t('APP.LOGOUT')}</button>
</>
)}
</div>
</nav>
);
}
|
- Zeilen 17–18: Die Komponente liest den Benutzer und die Abmeldefunktion aus dem Session-Store; sie wird neu angezeigt, wenn sich der Benutzer ändert (Anmeldung, Abmeldung, abgelaufene Sitzung);
- Zeilen 21–24: Abmeldung, dann die Anmeldeseite. Auch wenn der Server nicht antwortet, vergisst der Client den Benutzer (siehe [stores/session.ts]): Der Fehler wird ignoriert ([catch(() => {})]);
- Zeilen 32–37: Die Menüs hängen von der Rolle ab;
- Zeile 35: [NavLink] (Beispiel 17) setzt die [active]-Klasse aus [Bootstrap] auf das Menü der angezeigten Seite;
- Zeilen 59–64: die Schaltflächen FR / EN. [i18n.changeLanguage(l)]: Es wird keine Anfrage an den Server gesendet; die gesamte Seite wird lokal neu gerendert. [aria-pressed]: Ein Screenreader kündigt die Schaltfläche der aktuellen Sprache als „gedrückt“ an;
- Zeilen 67–73: die Rolle, der Name und die Schaltfläche zum Abmelden.
10.4.9.4. src/components/SuccessMessage.tsx und ErrorPanel.tsx
| // =========================================================================
// components/SuccessMessage.tsx - die ERFOLGSmeldung oben auf der Seite
// (Termin gespeichert, Arzt hinzugefügt...) - siehe stores/messages.ts.
// role="status": Ein Screenreader kündigt sie an, ohne den Benutzer zu unterbrechen.
// =========================================================================
import { useTranslation } from 'react-i18next';
import { useMessages } from '../stores/messages';
export default function SuccessMessage() {
const { t } = useTranslation();
const success = useMessages((m) => m.success);
return success && <div className="alert alert-success" role="status">{t(success.key, success.params)}</div>;
}
|
| // =========================================================================
// components/ErrorPanel.tsx - das Fehlerpanel UNTEN auf 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 { useTranslation } from 'react-i18next';
import { useMessages } from '../stores/messages';
export default function ErrorPanel() {
const { t } = useTranslation();
const error = useMessages((m) => m.error);
return error && <div className="error-panel" role="alert">{t(error.key, error.params)}</div>;
}
|
Zwei kleine Komponenten, die die Meldungen des Stores [useMessages] in der aktuellen Sprache anzeigen. [role="status"] und [role="alert"]: Ein Screenreader liest die Meldung vor, sobald sie erscheint – dezent bei einem Erfolg, sofort bei einem Fehler. Eine Komponente darf [null] (oder [false]) zurückgeben: In diesem Fall zeigt sie nichts an.
10.4.9.5. src/components/ConfirmDialog.tsx
| // =========================================================================
// components/ConfirmDialog.tsx
// -------------------------------------------------------------------------
// Der Dialog "Sind Sie sicher?" aus Beispiel 16, für die Tastatur ergänzt
// wie public/js/app.js der HTML-Anwendung:
// - Beim Öffnen geht 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 ginge der Fokus auf
// die ausgegraute Seite dahinter);
// - Beim Schließen geht der Fokus zurück an das Element, das ihn hatte (zum Beispiel
// die angeklickte Schaltfläche "Delete").
// "No, go back" statt "Cancel": Die Frage lautet manchmal "Cancel this
// appointment?", und eine Schaltfläche "Cancel" wäre dort mehrdeutig.
// Die Komponente wird einmal im Layout platziert; sie zeigt nichts an, solange
// der Bestätigungs-Store keine Frage hat (siehe stores/confirmation.ts).
// =========================================================================
import { useEffect, useRef, type KeyboardEvent, type MouseEvent } from 'react';
import { createPortal } from 'react-dom';
import { useTranslation } from 'react-i18next';
import { useConfirmation } from '../stores/confirmation';
export default function ConfirmDialog() {
const { t } = useTranslation();
const key = useConfirmation((c) => c.messageKey);
const answer = useConfirmation((c) => c.answer);
const dialog = useRef<HTMLDivElement>(null);
const noButton = useRef<HTMLButtonElement>(null);
// der Dialog öffnet sich: Wir merken uns das Element, das den Fokus hat, und geben ihn
// der Schaltfläche "No"; er schließt sich (Cleanup): Wir geben den Fokus zurück
const open = key !== null;
useEffect(() => {
if (!open) return;
const previousFocus = document.activeElement as HTMLElement | null;
noButton.current?.focus();
return () => previousFocus?.focus();
}, [open]);
if (key === null) {
return null; // Dialog geschlossen: nichts anzuzeigen
}
function onKeydown(e: KeyboardEvent<HTMLDivElement>) {
if (e.key === 'Escape') {
answer(false);
} else if (e.key === 'Tab' && dialog.current) {
const buttons = [...dialog.current.querySelectorAll('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
function onBackdropClick(e: MouseEvent<HTMLDivElement>) {
if (e.target === e.currentTarget) {
answer(false);
}
}
return createPortal(
<div onKeyDown={onKeydown}>
<div className="modal-backdrop fade show"></div>
<div ref={dialog} className="modal fade show d-block" tabIndex={-1} role="alertdialog" aria-modal="true"
aria-labelledby="confirmation-title" aria-describedby="confirmation-message" onClick={onBackdropClick}>
<div className="modal-dialog modal-dialog-centered">
<div className="modal-content">
<div className="modal-header">
<h5 id="confirmation-title" className="modal-title">{t('CONFIRMATION.TITLE')}</h5>
<button type="button" className="btn-close" aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} onClick={() => answer(false)}></button>
</div>
<div className="modal-body">
<p id="confirmation-message" className="mb-0">{t(key)}</p>
</div>
<div className="modal-footer">
<button ref={noButton} type="button" className="btn btn-secondary" onClick={() => answer(false)}>
{t('CONFIRMATION.NO')}
</button>
<button type="button" className="btn btn-danger" onClick={() => answer(true)}>{t('CONFIRMATION.YES')}</button>
</div>
</div>
</div>
</div>
</div>,
document.body,
);
}
|
Das Fenster aus Beispiel 16, verbunden mit dem Bestätigungs-Store und für die Tastaturbedienung vervollständigt:
- Zeilen 26–27: die gestellte Frage ([null]: Fenster geschlossen) und die Funktion, die sie beantwortet;
- Zeilen 33–39: ein Effekt, der von [open] abhängt: Beim Öffnen wird das Element, das den Fokus hat (die angeklickte Schaltfläche „Löschen“), gemerkt, und der Fokus wird auf die Schaltfläche „Nein, zurück“ gesetzt: Ein versehentliches Drücken der Eingabetaste löscht nichts. Das Aufräumen des Effekts, das beim Schließen erfolgt, gibt den Fokus an das gemerkte Element zurück;
- Zeilen 41–43: Fenster geschlossen: nichts anzuzeigen. Die Hooks werden VOR diesem [return] aufgerufen: Sie müssen bei jeder Anzeige des Fensters in derselben Reihenfolge aufgerufen werden;
- Zeilen 45–60: Esc bedeutet „Nein“. Tab und Umschalt+Tab halten den Fokus INNERHALB des Fensters: Tab springt von der letzten Schaltfläche zur ersten und umgekehrt; andernfalls würde der Fokus auf die ausgegraute Seite dahinter wandern;
- Zeilen 63–67: Ein Klick auf den ausgegrauten Hintergrund wird als „Nein“ behandelt. [e.target] ist das angeklickte Element, und [e.currentTarget] ist dasjenige, das den Handler trägt: Sie sind gleich, wenn der Klick auf den Hintergrund selbst erfolgte und nicht innerhalb des Fensters;
- Zeilen 69–94: [createPortal] (Beispiel 16) zeigt das Fenster am Ende von [<body>] an, außerhalb der Seite: Kein Stil der Seite kann es verfälschen;
- Zeile 72: für einen Screenreader ein Fenster, das eine dringende Antwort verlangt; [aria-labelledby] und [aria-describedby] verweisen auf seinen Titel und seine Frage.
| // =========================================================================
// components/InputField.tsx - ein vollständiges Formularfeld
// -------------------------------------------------------------------------
// Label + Feld + Hilfemeldung ODER Fehlermeldung. Alle
// Formulare der Anwendung verwenden es:
//
// <InputField fieldId="lastName" label="PERSONS.LASTNAME_LABEL" maxLength={20}
// value={form.lastName} onChange={(v) => edit('lastName', v)} error={submission.errors.lastName} />
//
// Es ist eine KONTROLLIERTE Komponente (siehe Beispiel 11): Der Wert gehört dem
// übergeordneten Formular. Der Fehler ist der vom SERVER zurückgegebene (siehe
// hooks/useFormSubmit.ts). label, help und error sind Übersetzungs
// schlüssel; params sind die Parameter ihrer Meldungen ({min}...).
// =========================================================================
import { useTranslation } from 'react-i18next';
interface Props {
fieldId: string; // die id des <input>, mit dem <label> verknüpft
label: string;
value: string;
onChange: (value: string) => void;
error?: string;
help?: string;
params?: Record<string, string>;
type?: 'text' | 'password';
maxLength?: number;
autoComplete?: string;
required?: boolean;
autoFocus?: boolean;
className?: string; // die Klassen des Blocks (mb-3, col-sm-6...)
}
export default function InputField({
fieldId, label, value, onChange, error, help, params = {}, type = 'text', maxLength,
autoComplete = 'off', required = false, autoFocus = false, className = '',
}: Props) {
const { t } = useTranslation();
const messageId = `${fieldId}-message`;
return (
<div className={className}>
<label className="form-label" htmlFor={fieldId}>{t(label)}</label>
<input id={fieldId} type={type} className={`form-control ${error ? 'is-invalid' : ''}`} value={value}
onChange={(e) => onChange(e.target.value)} maxLength={maxLength} autoComplete={autoComplete}
required={required} autoFocus={autoFocus} aria-invalid={error ? true : undefined} aria-describedby={messageId} />
{error ? (
<div className="invalid-feedback" id={messageId}>{t(error, params)}</div>
) : (
help && <div className="form-text" id={messageId}>{t(help, params)}</div>
)}
</div>
);
}
|
Ein vollständiges Formularfeld: Label, Feld, Hilfetext ODER Fehlermeldung. Alle Formulare der Anwendung verwenden es.
- Zeilen 18–32: seine Props; [label], [help] und [error] sind Übersetzungs-Props (SCHLÜSSEL);
- Zeilen 34–37: das Entpacken der Props mit Standardwerten ([type = 'text']);
- Zeile 39: der Bezeichner für den Hilfetext oder die Fehlermeldung, mit dem [aria-describedby] das Feld verknüpft; ein Screenreader liest ihn zusammen mit dem Feld vor;
- Zeilen 44–46: ein KONTROLLIERTES Feld (Beispiel 05): Sein Wert gehört dem übergeordneten Formular, das ihn über [onChange] erhält. [is-invalid]: der rote Rahmen von [Bootstrap];
- Zeilen 47–51: der vom Server zurückgegebene Fehler, andernfalls der Hilfetext.
10.4.9.7. src/components/PersonFields.tsx
| // =========================================================================
// components/PersonFields.tsx - Anrede, Vorname, Nachname
// -------------------------------------------------------------------------
// Die Identitätsfelder, drei Formularen gemeinsam: dem Arzt- / Client-Formular des ADMIN,
// "Create a patient account" und "Manage my account" (das Äquivalent zum
// Partial views/partials/personFields.hbs). Das übergeordnete Element übergibt ihr die
// Werte, die Fehler und die Funktion, die ein Feld ändert:
// <PersonFields values={form} errors={submission.errors} onChange={edit} />
// =========================================================================
import { useTranslation } from 'react-i18next';
import type { Identity } from '../api/types';
import InputField from './InputField';
const TITLES = ['Mr', 'Mme', 'Melle'];
interface Props {
values: Identity;
errors: Record<string, string>;
onChange: (field: keyof Identity, value: string) => void;
}
export default function PersonFields({ values, errors, onChange }: Props) {
const { t } = useTranslation();
return (
<>
<div className="mb-3">
<label className="form-label" htmlFor="title">{t('PERSONS.TITLE_LABEL')}</label>
<select id="title" className={`form-select ${errors.title ? 'is-invalid' : ''}`} value={values.title}
onChange={(e) => onChange('title', e.target.value)}>
{TITLES.map((title) => <option key={title}>{title}</option>)}
</select>
{errors.title && <div className="invalid-feedback">{t(errors.title)}</div>}
</div>
<div className="row g-3 mb-3">
<InputField className="col-sm-6" fieldId="firstName" label="PERSONS.FIRSTNAME_LABEL" maxLength={20} required
value={values.firstName} onChange={(v) => onChange('firstName', v)} error={errors.firstName} />
<InputField className="col-sm-6" fieldId="lastName" label="PERSONS.LASTNAME_LABEL" maxLength={20} required
value={values.lastName} onChange={(v) => onChange('lastName', v)} error={errors.lastName} />
</div>
</>
);
}
|
Anrede, Vorname und Nachname: Felder, die drei Formularen gemeinsam sind (Arzt oder Patient durch ADMIN, Kontoerstellung, Kontoverwaltung). Das Äquivalent zum Partial [views/partials/personFields.hbs] der HTML-Anwendung.
- Zeile 20: [keyof Identity]: type ['title' | 'firstName' | 'lastName']; der Compiler weist jeden anderen Feldnamen zurück;
- Zeile 31: Ein [<option>] ohne [value] hat seinen Text als Wert.
10.4.9.8. src/components/CaptchaField.tsx
| // =========================================================================
// components/CaptchaField.tsx - das CAPTCHA-Bild und das Eingabefeld
// -------------------------------------------------------------------------
// Eine Anzeigekomponente: das Bild (svg), der Link "Another image"
// (onReload) und das Feld, KONTROLLIERT vom übergeordneten Formular (value,
// onChange). Das Bild und sein Bezeichner stammen aus dem Hook useCaptcha, den
// das übergeordnete Element aufruft (siehe pages/Login.tsx): Es braucht sie,
// um die Antwort zu senden.
//
// dangerouslySetInnerHTML: Das SVG-Bild wird unverändert eingefügt. Hier ohne
// Gefahr, weil es von unserem Server erzeugt wird (Bibliothek
// svg-captcha) und nichts enthält, was von einem Benutzer stammt - siehe
// Beispiel 22.
// =========================================================================
import { useTranslation } from 'react-i18next';
interface Props {
svg: string;
value: string;
onChange: (value: string) => void;
onReload: () => void;
error?: string;
}
export default function CaptchaField({ svg, value, onChange, onReload, error }: Props) {
const { t } = useTranslation();
return (
<div className="mb-3">
<label className="form-label" htmlFor="captcha">{t('CAPTCHA.LABEL')}</label>
<div className="d-flex align-items-center gap-3 mb-2">
<div className="captcha-image" role="img" aria-label={t('CAPTCHA.IMAGE_ALT')} dangerouslySetInnerHTML={{ __html: svg }} />
<button type="button" className="btn btn-link btn-sm p-0" onClick={onReload}>{t('CAPTCHA.NEW_IMAGE')}</button>
</div>
<input id="captcha" type="text" maxLength={10} autoComplete="off" autoCapitalize="off" spellCheck={false}
className={`form-control ${error ? 'is-invalid' : ''}`} value={value} onChange={(e) => onChange(e.target.value)} />
{error ? <div className="invalid-feedback">{t(error)}</div> : <div className="form-text">{t('CAPTCHA.HELP')}</div>}
</div>
);
}
|
Eine reine Anzeigekomponente: das Bild, die Schaltfläche „Anderes Bild“ und das Feld, das vom übergeordneten Formular kontrolliert wird. Das Bild und sein Bezeichner stammen aus dem Hook [useCaptcha], den die Seite aufruft: Die Seite benötigt ihn, um die Antwort zu senden.
- Zeile 32: Das SVG-Bild wird unverändert eingefügt (Beispiel 22). HIER unbedenklich: Es wird von unserem Server erzeugt und enthält nichts, was von einem Benutzer stammt. [role="img"] und [aria-label]: Für einen Screenreader ist dies ein Bild mit seiner Beschreibung;
- Zeile 35: [autoCapitalize="off"] und [spellCheck={false}]: keine automatische Großschreibung (Smartphones) und keine Rechtschreibprüfung.
10.4.9.9. src/components/BookingDialog.tsx
| // =========================================================================
// components/BookingDialog.tsx - der Buchungsdialog 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 ruft auf
// - onConfirm, mit dem gewählten Patienten (null für einen Patienten, der
// für sich selbst bucht);
// - onClose.
// Die Terminkalender-Seite entscheidet, was damit geschieht (pages/Schedule.tsx).
// =========================================================================
import { useEffect, useState, type FormEvent, type MouseEvent } from 'react';
import { createPortal } from 'react-dom';
import { useTranslation } from 'react-i18next';
import type { Person } from '../api/types';
import { label } from '../formatting';
interface Props {
time: string; // "8:00 - 8:20"
clients: readonly Person[]; // ADMIN / DOCTOR: die zur Auswahl stehenden Patienten
patient: string | null; // USER: Der Patient ist der Benutzer selbst
submitting: boolean;
onConfirm: (clientId: number | null) => void;
onClose: () => void;
}
export default function BookingDialog({ time, clients, patient, submitting, onConfirm, onClose }: Props) {
const { t } = useTranslation();
const [clientId, setClientId] = useState<number | null>(null);
// Escape, irgendwo auf der Seite: Wir schließen
useEffect(() => {
const onKeydown = (e: globalThis.KeyboardEvent) => {
if (e.key === 'Escape') onClose();
};
document.addEventListener('keydown', onKeydown);
return () => document.removeEventListener('keydown', onKeydown);
}, [onClose]);
function confirm(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
onConfirm(clientId);
}
// ein Klick auf den ausgegrauten Hintergrund (und nicht in den Dialog selbst) schließt den Dialog
function onBackdropClick(e: MouseEvent<HTMLDivElement>) {
if (e.target === e.currentTarget) {
onClose();
}
}
return createPortal(
<>
<div className="modal-backdrop fade show"></div>
<div className="modal fade show d-block" tabIndex={-1} role="dialog" aria-modal="true" aria-labelledby="booking-title"
onClick={onBackdropClick}>
<div className="modal-dialog modal-dialog-centered">
<form className="modal-content" onSubmit={confirm}>
<div className="modal-header">
<h5 id="booking-title" className="modal-title">{t('BOOKING_DIALOG.TITLE')}</h5>
<button type="button" className="btn-close" aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} onClick={onClose}></button>
</div>
<div className="modal-body">
<p>{t('BOOKING_DIALOG.SLOT', { time })}</p>
{/* ein Patient bucht für sich selbst: keine Liste (und der Server
würde ein eventuelles clientId ohnehin ignorieren) */}
{patient !== null ? (
<p className="mb-0">{t('BOOKING_DIALOG.PATIENT_LABEL')}: <strong>{patient}</strong></p>
) : (
<>
<label className="form-label" htmlFor="clientId">{t('BOOKING_DIALOG.PATIENT_LABEL')}</label>
{/* autoFocus: Beim Anzeigen liegt der Fokus auf der Liste */}
<select id="clientId" className="form-select" autoFocus value={clientId ?? ''}
onChange={(e) => setClientId(e.target.value === '' ? null : Number(e.target.value))}>
<option value="">{t('BOOKING_DIALOG.CHOOSE_PATIENT')}</option>
{clients.map((c) => <option key={c.id} value={c.id}>{label(c)}</option>)}
</select>
</>
)}
</div>
<div className="modal-footer">
<button type="button" className="btn btn-secondary" onClick={onClose}>{t('BOOKING_DIALOG.CANCEL')}</button>
{/* ohne Liste hat die Bestätigungsschaltfläche den Fokus */}
<button type="submit" className="btn btn-primary" autoFocus={patient !== null} disabled={submitting}>
{t('BOOKING_DIALOG.CONFIRM')}
</button>
</div>
</form>
</div>
</div>
</>,
document.body,
);
}
|
Das Fenster zur Terminbuchung. Es kommuniziert nicht mit dem Server: Es ruft [onConfirm] mit dem ausgewählten Patienten auf, oder [onClose]; die Seite des Terminkalenders entscheidet, was damit geschieht.
- Zeilen 21–28: [clients]: die Liste der Patienten, für ADMIN und die Ärzte; [patient]: der Name des Patienten, der den Termin für sich selbst vereinbart ([null] für ADMIN und die Ärzte);
- Zeile 32: der in der Liste ausgewählte Patient;
- Zeilen 35–41: Esc schließt das Fenster, wo auch immer man sich auf der Seite befindet. Der Effekt abonniert das Ereignis [keydown] des Dokuments, und sein Aufräumen beendet das Abonnement beim Schließen. [globalThis.KeyboardEvent]: das Ereignis des Browsers, nicht das von [React], das denselben Namen trägt;
- Zeilen 43–46: [preventDefault()] verhindert, dass der Browser das Formular absendet;
- Zeilen 71–83: Ein Patient bucht für sich selbst: keine Liste. Der Server würde ein [clientId] ohnehin ignorieren;
- Zeile 78: Der Wert einer [<option>] ist immer ein String: Er wird in eine Zahl umgewandelt;
- Zeile 89: Ohne Liste erhält die Bestätigungsschaltfläche den Fokus.
10.4.10. Die Seiten
10.4.10.1. src/pages/Login.tsx
| // =========================================================================
// pages/Login.tsx - die Anmeldeseite (/login)
// -------------------------------------------------------------------------
// Dieselbe Seite wie views/login.hbs der HTML-Anwendung: Login, Passwort,
// CAPTCHA und eine zweite Schaltfläche "Create a patient account", die
// dasselbe CAPTCHA prüft, bevor die Kontoerstellung geöffnet wird.
//
// /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 Guard des Routers hinterlassen) statt der Startseite der Rolle.
// =========================================================================
import { useState, type FormEvent } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { useTranslation } from 'react-i18next';
import { api } from '../api/rdvmedecins.api';
import { homePage, useSession } from '../stores/session';
import { useMessages } from '../stores/messages';
import { useFormSubmit } from '../hooks/useFormSubmit';
import { useCaptcha } from '../hooks/useCaptcha';
import CaptchaField from '../components/CaptchaField';
import PageTitle from '../components/PageTitle';
export default function Login() {
const { t } = useTranslation();
const [params] = useSearchParams();
const navigate = useNavigate();
const logIn = useSession((s) => s.logIn);
const clearMessages = useMessages((m) => m.clear);
const submission = useFormSubmit();
const captcha = useCaptcha();
// das login aus der URL, falls vorhanden: der ANFANGSWERT des Felds
const urlLogin = (params.get('login') ?? '').slice(0, 30);
const [form, setForm] = useState({ login: urlLogin, password: '', captcha: '' });
function edit(field: keyof typeof form, value: string) {
setForm((f) => ({ ...f, [field]: value }));
submission.clearError(field);
}
// die beiden Schaltflächen teilen sich diese Abfolge: Senden, dann bei einem Fehler
// Fehlermeldung und NEUES Bild (jedes kann nur einmal verwendet werden)
async function attempt(action: () => Promise<unknown>): Promise<void> {
clearMessages();
const succeeded = await submission.submit(action);
if (!succeeded) {
setForm((f) => ({ ...f, captcha: '' }));
await captcha.reload();
}
}
async function onLogIn(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
await attempt(async () => {
await logIn(form.login.trim(), form.password, captcha.captchaId, form.captcha);
const redirect = params.get('redirect');
// nur ein INTERNER Pfad: niemals eine Weiterleitung auf eine andere Website
const internal = redirect !== null && redirect.startsWith('/') && !redirect.startsWith('//');
await navigate(internal ? redirect : homePage(useSession.getState().user));
});
}
async function createAccount() {
await attempt(async () => {
await api.registrationAccess(captcha.captchaId, form.captcha);
await navigate('/register');
});
}
return (
<div className="row justify-content-center">
<PageTitle titleKey="LOGIN.TITLE" />
<div className="col-sm-8 col-md-6 col-lg-5">
<div className="card p-4">
<h5 className="card-title mb-3">{t('LOGIN.TITLE')}</h5>
<form onSubmit={onLogIn}>
<div className="mb-3">
<label className="form-label" htmlFor="login">{t('LOGIN.LOGIN_LABEL')}</label>
{/* required: Der Browser weigert sich, das Formular abzusenden, solange das Feld leer ist.
autoFocus: der Fokus auf dem Login ... oder auf dem Passwort, wenn das Login bereits ausgefüllt ist */}
<input id="login" type="text" className="form-control" autoComplete="username" required
autoFocus={urlLogin === ''} value={form.login} onChange={(e) => edit('login', e.target.value)} />
</div>
<div className="mb-3">
<label className="form-label" htmlFor="password">{t('LOGIN.PASSWORD_LABEL')}</label>
<input id="password" type="password" className="form-control" autoComplete="current-password" required
autoFocus={urlLogin !== ''} value={form.password} onChange={(e) => edit('password', e.target.value)} />
</div>
<CaptchaField svg={captcha.svg} value={form.captcha} onChange={(v) => edit('captcha', v)}
onReload={captcha.reload} error={submission.errors.captcha} />
{/* type="submit": Eingabetaste in einem Feld löst "Log in" aus */}
<button type="submit" className="btn btn-primary w-100" disabled={submission.submitting}>{t('LOGIN.SUBMIT')}</button>
{/* type="button": Diese Schaltfläche sendet das Formular nicht ab (und daher
ignoriert daher die Pflichtfelder, hier nutzlos) */}
<button type="button" className="btn btn-outline-primary w-100 mt-3" disabled={submission.submitting} onClick={createAccount}>
{t('LOGIN.CREATE_ACCOUNT')}
</button>
<div className="form-text text-center">{t('LOGIN.CREATE_ACCOUNT_HELP')}</div>
</form>
<div className="text-muted small mt-3">
{t('LOGIN.DEMO_ACCOUNTS')}
<ul className="mb-0 mt-1">
<li><code>admin</code> - {t('LOGIN.DEMO_ADMIN')}</li>
<li><code>pelissier</code>, <code>tatou</code>, <code>dupont</code> - {t('LOGIN.DEMO_DOCTOR')}</li>
<li><code>martin</code>, <code>durand</code>, <code>bistrou</code>, <code>german</code> - {t('LOGIN.DEMO_USER')}</li>
</ul>
</div>
</div>
</div>
</div>
);
}
|
Die Seite [views/login.hbs] der HTML-Anwendung: Login, Passwort, CAPTCHA und eine zweite Schaltfläche „Patientenkonto erstellen“, die dasselbe CAPTCHA prüft, bevor der Vorgang zur Kontoerstellung beginnen darf.
- Zeilen 29–32: Was die Seite benötigt: die Anmeldung (Speicherung der Sitzung), das Löschen der Meldungen, das Absenden des Formulars und das CAPTCHA (unsere beiden Hooks);
- Zeilen 35–36: [/login?login=jbernard]: Unmittelbar nach der Kontoerstellung ist der Benutzername vorausgefüllt. [slice(0, 30)]: Wir übernehmen nicht mehr als die maximale Länge eines Benutzernamens. Die URL liefert nur den ANFANGSWERT des Felds;
- Zeilen 38–41: Wird ein Feld bearbeitet, erscheint sein neuer Wert, und jede Fehlermeldung verschwindet. [[field]: value]: eine Eigenschaft, deren Name berechnet wird;
- Zeilen 45–52: Beide Schaltflächen folgen demselben Ablauf: absenden und, falls das fehlschlägt, das CAPTCHA leeren und ein NEUES Bild laden; jedes wird nur einmal verwendet;
- Zeilen 54–63: Anmeldung, dann die nächste Seite:
- Zeile 58: die vor der Anmeldung angeforderte Seite, die der Router zwischengespeichert hat ([/login?redirect=/doctors]);
- Zeile 60: NUR ein interner Pfad: [/doctors], aber nicht [https://malicious-site.com] oder [//malicious-site.com] (eine „protokolllose“ Adresse, die auf eine andere Website verweist). Andernfalls würde ein bösartiger Link wie [/login?redirect=https://...] den Benutzer, der sich gerade angemeldet hat, auf eine andere Website schicken: Dies ist die sogenannte Schwachstelle „Open Redirect“;
- Zeile 61: andernfalls die Startseite der Rolle. [useSession.getState()]: Der Benutzer wurde GERADE erst im Store gespeichert; die Variable einer Komponente ändert sich dagegen erst beim nächsten Rendern;
- Zeilen 65–70: die zweite Schaltfläche: Das CAPTCHA wird vom Server geprüft, der ein Token (ein Cookie) für die Seite [/register] zurückgibt;
- Zeilen 84–85: [required]: Der Browser weigert sich, das Formular abzusenden, solange das Feld leer ist. Dies ist die einzige im Browser durchgeführte Validierung – sie dient lediglich der Bequemlichkeit. [autoFocus]: Der Fokus liegt auf dem Feld für den Benutzernamen oder, wenn dieser bereits ausgefüllt ist, auf dem Passwortfeld (Zeile 90);
- Zeile 97: [type="submit"]: Die Eingabe in einem Feld löst die Schaltfläche „Anmelden“ aus;
- Zeile 101: [type="button"]: Diese Schaltfläche sendet das Formular nicht ab und ignoriert daher die [required]-Felder, die hier nicht erforderlich sind.
10.4.10.2. src/pages/Schedule.tsx
Die funktionsreichste Seite der Anwendung. Wie in der HTML-Anwendung befindet sich ihr GESAMTER Zustand in der URL:
| /schedule?doctorId=1&day=2026-10-05 the schedule
/schedule?doctorId=1&day=2026-10-05&book=7 + the booking dialog
|
Die Seite FOLGT der URL: Sie liest ihre Parameter und bestimmt daraus, was angezeigt wird; Aktionen des Benutzers ändern ihrerseits die URL. So können Sie die Seite neu laden, ein Lesezeichen setzen und die Schaltflächen „Zurück“ und „Vor“ des Browsers verwenden.
| // =========================================================================
// pages/Schedule.tsx - die Terminkalender-Seite (/schedule)
// -------------------------------------------------------------------------
// Drei Blöcke, wie views/schedule.hbs der HTML-Anwendung:
// 1. die Auswahl des Arztes und des Tages;
// 2. der Terminkalender dieses Arztes an diesem Tag;
// 3. der Buchungsdialog eines Zeitfensters.
//
// Wie in der HTML-Anwendung liegt 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 /
// Vor des Browsers funktionieren. Die Seite FOLGT ihrer URL: Sie liest ihre
// drei Parameter (useSearchParams) und leitet daraus ab, was sie anzeigt;
// der Terminkalender ist eine TanStack-Query-Abfrage, deren Schlüssel den Arzt
// und den Tag enthält (siehe Beispiel 24); die Aktionen des Benutzers hingegen
// ändern die URL (navigate).
//
// Was jeder Benutzer sieht und tun kann, entscheidet der SERVER (Felder
// patient, mine, bookable, appointmentId jedes Zeitfensters): Die Seite zeigt es nur an.
// Ein Patient erhält nicht einmal die Namen der anderen Patienten.
// =========================================================================
import { useCallback, useEffect, useState, type FormEvent } from 'react';
import { Link, useNavigate, useSearchParams } from 'react-router';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useTranslation } from 'react-i18next';
import { ApiError } from '../api/api-error';
import { api } from '../api/rdvmedecins.api';
import type { ScheduleSlot, Person } from '../api/types';
import { today, isValidDate, timeRange, longDate, label } from '../formatting';
import { isManager, isPatient, useSession } from '../stores/session';
import { useMessages } from '../stores/messages';
import { confirm } from '../stores/confirmation';
import BookingDialog from '../components/BookingDialog';
import PageTitle from '../components/PageTitle';
// "3" -> 3; "", "abc", "-2", fehlend (null) -> null
function positiveInteger(value: string | null): number | null {
const n = Number(value);
return value !== null && value !== '' && Number.isInteger(n) && n > 0 ? n : null;
}
// die Adresse des Terminkalenders (ohne den Buchungsdialog oder mit ihm)
function scheduleUrl(doctorId: number | null, day: string, book?: number): string {
const params = new URLSearchParams({ doctorId: String(doctorId ?? ''), day });
if (book !== undefined) {
params.set('book', String(book));
}
return `/schedule?${params}`;
}
// -------------------------------------------------------------------------
// 1. die Auswahl des Arztes und des Tages: ein kleines Formular, dessen Zustand
// erst vor dem Absenden verwendet wird. Es STARTET mit den Werten der URL; die Seite gibt
// ihm einen Schlüssel, der sich mit ihnen ändert: React erzeugt es dann neu, und es
// beginnt erneut mit den neuen Werten (Zurück-Schaltfläche...).
// -------------------------------------------------------------------------
interface PickerProps {
doctors: Person[];
doctorId: number | null;
day: string;
onView: (doctorId: number | null, day: string) => void;
}
function DoctorDayPicker({ doctors, doctorId, day, onView }: PickerProps) {
const { t } = useTranslation();
const [chosenDoctor, setChosenDoctor] = useState(doctorId);
const [chosenDay, setChosenDay] = useState(day);
function view(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
onView(chosenDoctor, chosenDay);
}
return (
<form className="card p-3 mb-3" onSubmit={view}>
<div className="row g-2 align-items-end">
<div className="col-sm-5">
<label className="form-label" htmlFor="doctorId">{t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')}</label>
<select id="doctorId" className="form-select" required value={chosenDoctor ?? ''}
onChange={(e) => setChosenDoctor(positiveInteger(e.target.value))}>
<option value="">{t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')}</option>
{doctors.map((d) => <option key={d.id} value={d.id}>{label(d)}</option>)}
</select>
</div>
<div className="col-sm-4">
<label className="form-label" htmlFor="day">{t('DOCTOR_DAY_PICKER.DAY_LABEL')}</label>
<input id="day" type="date" className="form-control" required value={chosenDay}
onChange={(e) => setChosenDay(e.target.value)} />
</div>
<div className="col-sm-3">
<button type="submit" className="btn btn-primary w-100">{t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE')}</button>
</div>
</div>
</form>
);
}
// -------------------------------------------------------------------------
// die Seite
// -------------------------------------------------------------------------
export default function Schedule() {
const { t, i18n } = useTranslation();
const navigate = useNavigate();
const queryClient = useQueryClient();
const user = useSession((s) => s.user);
// die Aktionen des Messages-Stores: Funktionen, die sich nie
// ändern; getState() liefert sie, ohne die Seite für die Meldungen zu abonnieren
const { showSuccess, showError, showApiError, flash } = useMessages.getState();
const [submitting, setSubmitting] = useState(false);
// die Parameter der URL
const [params] = useSearchParams();
const urlDoctorId = positiveInteger(params.get('doctorId'));
const urlDay = params.get('day');
const bookId = positiveInteger(params.get('book'));
// der Tag: der aus der URL, wenn er gültig ist, sonst heute
const invalidDay = urlDay !== null && !isValidDate(urlDay);
const day = urlDay !== null && !invalidDay ? urlDay : today();
// die Listen: die Ärzte für alle; die Patienten nur für diejenigen,
// die sie lesen dürfen (ADMIN, DOCTOR: Buchungsdialog)
const doctors = useQuery({ queryKey: ['doctors'], queryFn: () => api.list('doctors') });
const clients = useQuery({
queryKey: ['clients'],
queryFn: () => api.list('clients'),
enabled: isManager(user),
});
// der Terminkalender: Ohne Arzt in der URL sieht ein DOCTOR SEINEN Terminkalender (der
// Server findet ihn anhand des Tokens); die anderen sehen nichts
const withSchedule = !invalidDay && (urlDoctorId !== null || user?.role === 'DOCTOR');
const schedule = useQuery({
queryKey: ['schedule', urlDoctorId, day],
queryFn: () => api.schedule(urlDoctorId, day),
enabled: withSchedule,
});
const s = withSchedule ? schedule.data : undefined;
// der angezeigte Arzt: der aus der URL oder der aus dem empfangenen Terminkalender (DOCTOR)
const doctorId = urlDoctorId ?? s?.doctor.id ?? null;
// ein ungültiges Datum in der URL: eine Meldung (ein EFFEKT: Er wirkt auf den
// Messages-Store, nicht auf das Rendering dieser Komponente)
useEffect(() => {
if (invalidDay) {
showError('ERRORS.INVALID_DATE');
}
}, [invalidDay, showError]);
// das Zeitfenster, dessen Buchungsdialog geöffnet ist (?book=7),
// nur wenn es von diesem Benutzer buchbar ist
const slotToBook = s?.slots.find((c) => c.id === bookId && c.bookable) ?? null;
// der Name des angemeldeten Patienten (USER) oder null für ADMIN und DOCTOR
const patient = isPatient(user) ? (user?.name ?? '') : null;
// -----------------------------------------------------------------------
// Aktionen
// -----------------------------------------------------------------------
// "View schedule": Wir ändern die URL, die Seite folgt
function viewSchedule(chosenDoctorId: number | null, chosenDay: string) {
navigate(scheduleUrl(chosenDoctorId, chosenDay));
}
// useCallback: dieselbe Funktion von einem Rendering zum nächsten (der Buchungs
// dialog verwendet sie in den Abhängigkeiten eines Effekts)
const closeBooking = useCallback(() => navigate(scheduleUrl(doctorId, day)), [navigate, doctorId, day]);
// der Server ist die Referenz: Nach jeder Aktion wird der Terminkalender erneut gelesen
// (und der Bereich des Patienten, der seinen Termin zeigt)
const reload = () =>
Promise.all([queryClient.invalidateQueries({ queryKey: ['schedule'] }), queryClient.invalidateQueries({ queryKey: ['my-area'] })]);
async function confirmBooking(clientId: number | null) {
if (slotToBook === null) {
return;
}
setSubmitting(true);
try {
await api.book(day, slotToBook.id, isManager(user) ? clientId : null);
flash('success', 'SCHEDULE.BOOKED');
} catch (e) {
if (e instanceof ApiError && e.key === 'ERRORS.CHOOSE_PATIENT') {
// kein Patient gewählt: Der Dialog bleibt offen
showError(e.key);
return; // (finally wird trotzdem ausgeführt)
}
if (!(e instanceof ApiError)) {
throw e;
}
// zwischenzeitlich belegtes Zeitfenster, Patient, der bereits einen Termin hat...:
// Die Meldung wird im Terminkalender angezeigt, Dialog geschlossen
flash('error', e.key, e.params);
} finally {
setSubmitting(false);
}
await closeBooking();
await reload();
}
async function cancel(c: ScheduleSlot) {
if (c.appointmentId === null || !(await confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
try {
await api.cancelAppointment(c.appointmentId);
showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
showApiError(e);
}
await reload();
}
// -----------------------------------------------------------------------
// Rendering
// -----------------------------------------------------------------------
let content;
if (schedule.isLoading && !s) {
content = <p className="text-muted">{t('APP.LOADING')}</p>;
} else if (s) {
content = (
<div className="card p-3">
<h5>{t('SCHEDULE.TITLE_PREFIX')} {longDate(s.day, i18n.language)} - {label(s.doctor)}</h5>
{s.slots.length > 0 ? (
<table className="table table-hover align-middle">
<thead>
<tr>
<th>{t('SCHEDULE.COLUMN_SLOT')}</th>
<th>{t('SCHEDULE.COLUMN_STATUS')}</th>
<th></th>
</tr>
</thead>
<tbody>
{s.slots.map((c) => (
<tr key={c.id} className={c.bookable ? 'free-slot' : ''}>
<td>{timeRange(c)}</td>
<td>
{c.free ? (
<span className="badge text-bg-success">{t('SCHEDULE.FREE')}</span>
) : c.patient ? (
<span className={`badge ${c.mine ? 'text-bg-primary' : 'text-bg-secondary'}`}>{label(c.patient)}</span>
) : (
<span className="badge text-bg-secondary">{t('SCHEDULE.BOOKED_BY_OTHER')}</span>
)}
</td>
<td className="text-end">
{/* "Book" ist ein LINK: Er fügt &book=... zur URL hinzu, die
den Buchungsdialog öffnet */}
{c.bookable && (
<Link className="btn btn-sm btn-outline-success" to={scheduleUrl(doctorId, day, c.id)}>
{t('SCHEDULE.BOOK')}
</Link>
)}
{c.appointmentId !== null && (
<button type="button" className="btn btn-sm btn-outline-danger" onClick={() => cancel(c)}>
{t('SCHEDULE.CANCEL_APPOINTMENT')}
</button>
)}
</td>
</tr>
))}
</tbody>
</table>
) : (
<p className="text-muted mb-0">{t('SCHEDULE.NO_SLOTS')}</p>
)}
</div>
);
} else {
content = <p className="text-muted">{t('SCHEDULE.EMPTY_STATE')}</p>;
}
return (
<>
<PageTitle titleKey="SCHEDULE.PAGE_TITLE" />
<DoctorDayPicker key={`${doctorId}|${day}`} doctors={doctors.data ?? []} doctorId={doctorId} day={day}
onView={viewSchedule} />
{/* Patient, der bereits einen bevorstehenden Termin hat: Deshalb gibt es keine Schaltfläche "Book" */}
{s?.info && (
<div className="alert alert-info">
{t(s.info)} <Link to="/my-area" className="alert-link">{t('APP.MENU_MY_AREA')}</Link>
</div>
)}
{content}
{/* 3. der Buchungsdialog, nur wenn die URL &book=... enthält */}
{slotToBook && (
<BookingDialog time={timeRange(slotToBook)} clients={clients.data ?? []} patient={patient}
submitting={submitting} onConfirm={confirmBooking} onClose={closeBooking} />
)}
</>
);
}
|
- Zeilen 39–42: Ein Parameter der URL ist ein von beliebiger Seite eingegebener String; nur eine positive ganze Zahl wird übernommen;
- Zeilen 45–51: die URL des Terminkalenders, mit oder ohne Buchungsfenster;
- Zeilen 66–98: das Formular zur Auswahl von Arzt und Datum, eine Komponente derselben Datei. Sein Zustand wird nur vor dem Absenden verwendet: Er wird mit den Werten aus der URL gefüllt (Zeilen 68–69). [useState(value)] verwendet seinen Wert jedoch nur bei der Anzeige: Ändert sich die URL (über die Schaltfläche „Zurück“), würde das Formular die vorherige Auswahl behalten. Daher der Schlüssel, den ihm die Seite weiter unten zuweist;
- Zeilen 114–120: die Parameter der URL. Der Tag: der Tag aus der URL, wenn er gültig ist, andernfalls heute;
- Zeilen 124–129: die Listen, mit [TanStack Query] (Beispiel 24). Der Schlüssel [['doctors']] verweist auf die Daten im Cache: Eine andere Seite, die denselben Schlüssel anfordert, erhält sie ohne neue Anfrage. [enabled]: Patienten nur für diejenigen, die sie einsehen dürfen (ADMIN und Ärzte, für das Terminfenster); für einen Patienten wird die Anfrage nicht gesendet;
- Zeilen 133–138: der Terminkalender. Sein Schlüssel enthält den Arzt und den Tag: Ändert sich die URL, ändert sich der Schlüssel, und [TanStack Query] sendet die neue Anfrage von selbst. Ist in der URL kein Arzt angegeben, sieht ein angemeldeter Arzt SEINEN EIGENEN Terminkalender; andere sehen nichts;
- Zeile 141: der angezeigte Arzt: der aus der URL, andernfalls der aus dem empfangenen Terminkalender;
- Zeilen 145–149: ein ungültiges Datum in der URL: eine Meldung. Dies ist ein EFFEKT: Wir greifen auf den Meldungs-Store zu, nicht auf die Anzeige dieser Komponente. Während die Anzeige aktiv ist, ändern wir niemals einen anderen Zustand;
- Zeile 153: der Zeitslot, dessen Buchungsfenster geöffnet ist ([?book=7]), nur wenn er für diesen Benutzer buchbar ist: Eine von Hand erstellte URL öffnet nichts;
- Zeilen 162–164: „Terminkalender anzeigen“ ändert die URL; die Seite aktualisiert sich entsprechend;
- Zeile 168: Das Schließen des Fensters führt zur URL des Terminkalenders zurück. [useCallback]: dieselbe Funktion von einer Anzeige zur nächsten, weil das Buchungsfenster sie in den Abhängigkeiten eines Effekts verwendet (siehe [BookingDialog.tsx]): Eine neue Funktion bei jeder Anzeige würde den Effekt jedes Mal auslösen;
- Zeilen 172–173: Die Daten des Servers haben Vorrang: Nach jeder Aktion werden der Terminkalender (und der Patientenbereich, der den Termin des Patienten anzeigt) aktualisiert. [TanStack Query] liest die angezeigten Daten sofort neu; Daten, die nicht angezeigt werden, werden bei der nächsten Verwendung neu gelesen;
- Zeilen 175–200: die Buchung:
- Zeile 181: ADMIN und die Ärzte senden den ausgewählten Patienten; ein Patient bucht für sich selbst;
- Zeile 182: Die Meldung erscheint nach der Navigation, die das Fenster schließt;
- Zeilen 184–188: Kein Patient ausgewählt: Das Fenster bleibt geöffnet und zeigt die Meldung an. [return] innerhalb eines [try]: Der Block [finally] wird trotzdem ausgeführt;
- Zeile 194: Andere Fehler (Zeitslot bereits vergeben, Patient hat bereits einen Termin usw.) werden bei geschlossenem Fenster im Terminkalender angezeigt;
- Zeilen 202–213: die Stornierung nach Bestätigung: [await confirm(...)] wartet auf die Antwort des Benutzers (siehe [stores/confirmation.ts]);
- Zeilen 218–272: der Hauptinhalt, der vor dem JSX berechnet wird: eine Wartemeldung, der Terminkalender oder eine Aufforderung, einen Arzt auszuwählen. Ein gewöhnliches [if / else] ist oft lesbarer als eine Kaskade von [? :]-Ausdrücken innerhalb des JSX;
- Zeilen 239–245: der Status des Zeitslots: frei, der Name des Patienten (blau, wenn es der angemeldete Patient ist) oder „Gebucht“: Ein Patient erhält NICHT die Namen anderer Patienten; der Server sendet sie nicht;
- Zeilen 250–254: „Buchen“ ist ein LINK, [<Link>]: Er fügt [&book=...] an die URL an, wodurch das Buchungsfenster geöffnet wird;
- Zeile 255: „Stornieren“, wenn der Server angegeben hat, dass der Benutzer diesen Termin stornieren kann;
- Zeile 277: Der Schlüssel des Formulars enthält den Arzt und den Tag. Wenn sich diese ändern, ändert sich der Schlüssel: [React] zerstört das Formular und erstellt ein neues, das mit den neuen Werten beginnt. So „setzt“ [React] eine Komponente „zurück“;
- Zeilen 281–285: Ein Patient, der bereits einen bevorstehenden Termin hat: Dies erklärt, warum es keine Schaltfläche „Buchen“ gibt;
- Zeilen 290–293: Das Buchungsfenster erscheint nur, wenn die URL [&book=...] enthält.
10.4.10.3. src/pages/persons.config.ts
| // =========================================================================
// pages/persons.config.ts - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Verwaltungsseiten 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.tsx,
// PersonForm.tsx); nur die Adresse der API und die
// Schlüssel der Beschriftungen ändern sich, hier beschrieben. Der Router übergibt jeder Seite den Typ
// (siehe routes.tsx).
// =========================================================================
import type { 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 "hinzugefügt / aktualisiert / gelöscht"
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 der Ärzte und der Patienten sind IDENTISCH: dieselbe Liste, dasselbe Formular. Wie in der HTML-Anwendung (abstrakte Klasse [PersonsController]) werden sie nur EINMAL geschrieben; es ändern sich nur die Adresse der API (der Typ, ['doctors'] oder ['clients']) und die Label-Schlüssel, die hier beschrieben sind.
- Zeilen 14–23: die für jeden Typ spezifischen Übersetzungsschlüssel;
- Zeile 25: [Record<PersonType, PersonKeys>]: ein Objekt, das genau eine Eigenschaft pro Typ hat; [doctors] und [clients]: Der Compiler meldet ein fehlendes Element;
- Zeilen 49–51: die Parameter [{{name}}] und [{{login}}] für die Meldungen „hinzugefügt / geändert / gelöscht“.
10.4.10.4. src/pages/Persons.tsx
| // =========================================================================
// pages/Persons.tsx - die Liste der Ärzte ODER der Clients (ADMIN)
// -------------------------------------------------------------------------
// Eine einzige Seite für beide: Der Typ ('doctors' oder 'clients') kommt
// als Prop an (siehe routes.tsx); die jeweils spezifischen Beschriftungen stehen in
// persons.config.ts. Äquivalent zu views/persons/list.hbs der
// HTML-Anwendung.
// =========================================================================
import { Link } from 'react-router';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useTranslation } from 'react-i18next';
import { api, type PersonType } from '../api/rdvmedecins.api';
import type { Person } from '../api/types';
import { useMessages } from '../stores/messages';
import { confirm } from '../stores/confirmation';
import PageTitle from '../components/PageTitle';
import { PERSON_KEYS, messageParams } from './persons.config';
export default function Persons({ type }: { type: PersonType }) {
const { t } = useTranslation();
const queryClient = useQueryClient();
const keys = PERSON_KEYS[type];
// die Liste; der Schlüssel enthält den Typ: Ärzte und Clients haben jeweils ihre eigene
const persons = useQuery({ queryKey: [type], queryFn: () => api.list(type) });
async function remove(p: Person) {
if (!(await confirm(keys.confirmDelete))) {
return;
}
const messages = useMessages.getState();
try {
await api.remove(type, p.id);
messages.showSuccess(keys.deleted, messageParams(p));
} catch (e) {
// ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
messages.showApiError(e);
}
await queryClient.invalidateQueries({ queryKey: [type] });
}
const list = persons.data;
let content;
if (list === undefined) {
// noch nicht geladen (oder Laden fehlgeschlagen: Die Meldung steht unten auf der Seite)
content = <p className="text-muted mb-0">{t('APP.LOADING')}</p>;
} else if (list.length === 0) {
content = <p className="text-muted mb-0">{t(keys.empty)}</p>;
} else {
content = (
<table className="table table-hover align-middle mb-0">
<thead>
<tr>
<th>{t('PERSONS.COLUMN_TITLE')}</th>
<th>{t('PERSONS.COLUMN_FIRSTNAME')}</th>
<th>{t('PERSONS.COLUMN_LASTNAME')}</th>
<th>{t('PERSONS.COLUMN_LOGIN')}</th>
<th></th>
</tr>
</thead>
<tbody>
{list.map((p) => (
<tr key={p.id}>
<td>{p.title}</td>
<td>{p.firstName}</td>
<td>{p.lastName}</td>
<td><code>{p.login}</code></td>
<td className="text-end">
<div className="d-inline-flex gap-2">
<Link className="btn btn-sm btn-outline-primary" to={`/${type}/${p.id}/edit`}>{t('PERSONS.EDIT')}</Link>
<button type="button" className="btn btn-sm btn-outline-danger" onClick={() => remove(p)}>
{t('PERSONS.DELETE')}
</button>
</div>
</td>
</tr>
))}
</tbody>
</table>
);
}
return (
<>
<PageTitle titleKey={keys.title} />
<div className="d-flex justify-content-between align-items-center mb-3">
<h4 className="mb-0">{t(keys.title)}</h4>
<Link className="btn btn-primary" to={`/${type}/add`}>{t(keys.add)}</Link>
</div>
<div className="card p-3">{content}</div>
</>
);
}
|
Die Liste der Ärzte oder Patienten. Der Typ wird als Property übergeben (siehe [routes.tsx]).
- Zeile 25: die Liste. Ihr Schlüssel ist der Typ: Ärzte und Patienten haben jeweils ihren eigenen. Die Liste der Ärzte sind dieselben Daten wie die Liste im Terminkalender (Schlüssel [['doctors']]): Beide profitieren vom Cache;
- Zeilen 27–40: Das Löschen nach Bestätigung, gefolgt vom Neuladen der Liste. Ein Arzt, der noch Termine hat, kann nicht gelöscht werden: Der Server gibt eine 409-Antwort zurück, und am Ende der Seite wird eine Meldung angezeigt;
- Zeile 31: [getState()] liefert die Funktionen des Stores, ohne die Seite auf Meldungen zu abonnieren: Sie muss nicht neu geladen werden, wenn sich eine Meldung ändert;
- Zeilen 44–81: der Inhalt: „Wird geladen …“, „Keine Ärzte“ oder die Tabelle;
- Zeile 70: „Bearbeiten“ ist ein Link zur Formularseite.
10.4.10.5. src/pages/PersonForm.tsx
| // =========================================================================
// pages/PersonForm.tsx - Erstellung ODER Aktualisierung eines Arztes oder
// eines Clients (ADMIN)
// -------------------------------------------------------------------------
// /doctors/add -> Erstellung (kein Parameter id)
// /doctors/3/edit -> Aktualisierung (Parameter id = "3")
// (und dieselben Adressen unter /clients). Äquivalent zu
// views/persons/form.hbs der HTML-Anwendung.
//
// Zwei Komponenten:
// - PersonForm liest den zu aktualisierenden Datensatz (falls vorhanden);
// - Form wird erst angezeigt, wenn der Datensatz gelesen wurde: Es STARTET mit
// seinen Werten (Anfangszustand), ohne sie später kopieren zu müssen.
// Hier wird keine Regel geprüft: Der Server validiert alles, und seine Fehler
// werden unter den Feldern angezeigt (siehe hooks/useFormSubmit.ts).
// Die mit dem Datensatz gelesene VERSION geht mit der Aktualisierung zurück: Hat ein anderer
// ADMIN ihn zwischenzeitlich geändert, antwortet der Server mit 409 CONCURRENT_UPDATE.
// =========================================================================
import { useEffect, useState, type FormEvent } from 'react';
import { Link, useNavigate, useParams } from 'react-router';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useTranslation } from 'react-i18next';
import { ApiError } from '../api/api-error';
import { api, type PersonType } from '../api/rdvmedecins.api';
import type { PersonData } from '../api/types';
import { useMessages } from '../stores/messages';
import { useFormSubmit } from '../hooks/useFormSubmit';
import PersonFields from '../components/PersonFields';
import InputField from '../components/InputField';
import PageTitle from '../components/PageTitle';
import ErrorPage from './ErrorPage';
import { PERSON_KEYS, messageParams } from './persons.config';
const EMPTY: PersonData = { title: 'Mr', firstName: '', lastName: '', login: '', password: '' };
// -------------------------------------------------------------------------
// das Formular selbst
// -------------------------------------------------------------------------
interface FormProps {
type: PersonType;
id: number | null; // null: Erstellung
initial: PersonData;
}
function Form({ type, id, initial }: FormProps) {
const { t } = useTranslation();
const navigate = useNavigate();
const queryClient = useQueryClient();
const submission = useFormSubmit();
const [form, setForm] = useState(initial);
const keys = PERSON_KEYS[type];
const creating = id === null;
function edit(field: keyof PersonData, value: string) {
setForm((f) => ({ ...f, [field]: value }));
submission.clearError(field);
}
async function save(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
const messages = useMessages.getState();
const succeeded = await submission.submit(async () => {
const p = id === null ? await api.add(type, form) : await api.edit(type, id, form);
messages.flash('success', creating ? keys.added : keys.edited, messageParams(p));
});
const key = useMessages.getState().error?.key;
if (succeeded) {
await queryClient.invalidateQueries({ queryKey: [type] }); // die Liste hat sich geändert
navigate(`/${type}`);
} else if (key === 'ERRORS.DOCTOR_NOT_FOUND' || key === 'ERRORS.PATIENT_NOT_FOUND') {
// zwischenzeitlich von einem anderen ADMIN gelöscht: zurück zur Liste
messages.flash('error', key);
navigate(`/${type}`);
}
}
return (
<div className="row justify-content-center">
<div className="col-md-8 col-lg-6">
<div className="card p-4">
<h5 className="card-title mb-3">{t(creating ? keys.add : keys.edit)}</h5>
{/* noValidate: Der SERVER validiert (er ist die Referenz) */}
<form noValidate onSubmit={save}>
<PersonFields values={form} errors={submission.errors} onChange={edit} />
<h6 className="mt-4 text-muted">{t('PERSONS.ACCOUNT_SECTION')}</h6>
<InputField className="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" maxLength={30}
value={form.login} onChange={(v) => edit('login', v)} error={submission.errors.login}
help={creating ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT'} />
{/* nie vorausgefüllt: Das Passwort kommt nie vom Server zurück */}
<InputField className="mb-4" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" maxLength={72}
autoComplete="new-password" value={form.password} onChange={(v) => edit('password', v)}
error={submission.errors.password} params={submission.params}
help={creating ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'} />
<div className="d-flex gap-2">
<button type="submit" className="btn btn-primary" disabled={submission.submitting}>{t('PERSONS.SAVE')}</button>
<Link className="btn btn-secondary" to={`/${type}`}>{t('PERSONS.BACK')}</Link>
</div>
</form>
</div>
</div>
</div>
);
}
// -------------------------------------------------------------------------
// die Seite: Erstellung oder Lesen des zu aktualisierenden Datensatzes
// -------------------------------------------------------------------------
export default function PersonForm({ type }: { type: PersonType }) {
const { id: urlId } = useParams(); // undefined bei einer Erstellung
const navigate = useNavigate();
const keys = PERSON_KEYS[type];
const validId = urlId === undefined || /^\d+$/.test(urlId);
const id = urlId === undefined || !validId ? null : Number(urlId);
// Aktualisierung: Der Datensatz wird gelesen (einschließlich seiner Version)
// - gcTime: 0: Der Datensatz wird nach dem Besuch nicht im Cache behalten; der
// nächste Besuch liest ihn erneut, immer aktuell (sonst würde das Formular
// mit einer veralteten Version starten: 409 CONCURRENT_UPDATE);
// - meta.errorHandled: Ein Lesefehler wird HIER behandelt und nicht
// vom gemeinsamen Fehler-Handler (siehe main.tsx)
const details = useQuery({
queryKey: [type, id],
queryFn: () => api.read(type, id!),
enabled: id !== null,
gcTime: 0,
meta: { errorHandled: true },
});
// Datensatz existiert nicht (zwischenzeitlich gelöscht...): zurück zur Liste
useEffect(() => {
if (details.error instanceof ApiError) {
useMessages.getState().flash('error', details.error.key, details.error.params);
navigate(`/${type}`);
}
}, [details.error, navigate, type]);
// /doctors/abc/edit: Diese Adresse existiert nicht
if (!validId) {
return <ErrorPage code={404} />;
}
const p = details.data;
return (
<>
<PageTitle titleKey={id === null ? keys.add : keys.edit} />
{id === null ? (
<Form type={type} id={null} initial={EMPTY} />
) : (
p && (
<Form type={type} id={id}
initial={{ title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', password: '', version: p.version }} />
)
)}
</>
);
}
|
Eine einzige Seite für das Erstellen ([/doctors/add]) und das Bearbeiten ([/doctors/3/edit]), bestehend aus zwei Komponenten:
- Zeilen 46–106: das Formular selbst. Es wird erst angezeigt, nachdem der Datensatz gelesen wurde, und BEGINNT mit seinen Werten ([useState(initial)]): Sie müssen später nicht in einem Effekt kopiert werden, wenn der Datensatz eintrifft:
- Zeilen 55–58: Wird ein Feld bearbeitet, verschwindet sein Fehler;
- Zeilen 60–76: das Speichern. Bei einer Änderung enthält [form] die VERSION, die zusammen mit dem Datensatz gelesen wurde: Hat ein anderer ADMIN ihn in der Zwischenzeit geändert, antwortet der Server mit einer 409 [ERRORS.CONCURRENT_UPDATE];
- Zeilen 68–70: Bei Erfolg hat sich die Liste geändert: Sie wird invalidiert, dann kehrt das Programm mit der Meldung zu ihr zurück;
- Zeilen 71–75: Der Datensatz wurde in der Zwischenzeit gelöscht: Rückkehr zur Liste. Die anderen Fehler bleiben im Formular angezeigt;
- Zeile 84: [noValidate]: Der Browser validiert die [required]-Felder nicht; es ist der SERVER, der validiert, und er ist maßgeblich;
- Zeile 91: Das Passwortfeld wird nie vorausgefüllt: Das Passwort wird vom Server nie zurückgegeben;
- Zeilen 111–159: die Seite:
- Zeile 112: der Routenparameter [:id], der bei einer Neuanlage fehlt;
- Zeilen 124–130: das Lesen des Datensatzes bei einer Änderung. [gcTime: 0]: Der Datensatz wird nach dem Besuch nicht zwischengespeichert; beim nächsten Besuch wird er neu gelesen und bleibt so aktuell (andernfalls würde das Formular mit einer veralteten Version beginnen). [meta: { errorHandled: true }]: Ein Lesefehler wird hier behandelt und nicht vom gemeinsamen Handler (siehe [main.tsx]);
- Zeilen 133–138: Der Datensatz existiert nicht (in der Zwischenzeit gelöscht, Adresse von Hand eingegeben ...): Rückkehr zur Liste mit einer Meldung;
- Zeilen 141–143: [/doctors/abc/edit]: Diese Adresse existiert nicht;
- Zeilen 149–156: eine Neuanlage: das leere Formular; eine Änderung: das Formular, sobald der Datensatz gelesen wurde. [login: p.login ?? '']: Der Login einer Person wird nur an ADMIN gesendet; er ist im Typ [Person] optional.
10.4.10.6. src/pages/Register.tsx
| // =========================================================================
// pages/Register.tsx - "Create a patient account" (/register)
// -------------------------------------------------------------------------
// Hierher gelangt man erst, nachdem man das CAPTCHA der Anmeldeseite kopiert hat
// (Schaltfläche "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 Formular des ADMIN, aber Login und
// Passwort sind Pflicht, mit Bestätigung. Äquivalent zu
// views/account/registration.hbs der HTML-Anwendung.
// =========================================================================
import { useState, type FormEvent } from 'react';
import { Link, useNavigate } from 'react-router';
import { useTranslation } from 'react-i18next';
import { api } from '../api/rdvmedecins.api';
import type { Registration } from '../api/types';
import { useMessages } from '../stores/messages';
import { useFormSubmit } from '../hooks/useFormSubmit';
import PersonFields from '../components/PersonFields';
import InputField from '../components/InputField';
import PageTitle from '../components/PageTitle';
// Mindestlänge eines von einem Patienten gewählten Passworts: gleicher Wert
// wie beim Server (der bei dem Fehler PASSWORD_TOO_SHORT auch {min} zurückgibt)
const PASSWORD_MIN = '6';
export default function Register() {
const { t } = useTranslation();
const navigate = useNavigate();
const submission = useFormSubmit();
const [form, setForm] = useState<Registration>({
title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '',
});
// die Parameter der Hilfemeldung UND der Passwortfehler
const passwordParams = { min: PASSWORD_MIN, ...submission.params };
function edit(field: keyof Registration, value: string) {
setForm((f) => ({ ...f, [field]: value }));
submission.clearError(field);
}
async function create(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
let login = '';
const succeeded = await submission.submit(async () => {
login = (await api.register(form)).login;
});
const messages = useMessages.getState();
if (succeeded) {
// zurück zur Anmeldeseite, Login vorausgefüllt
messages.flash('success', 'REGISTRATION.DONE', { login });
navigate(`/login?login=${encodeURIComponent(login)}`);
} else if (messages.error?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
// Pass abgelaufen (15 Minuten): zurück zum CAPTCHA
messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
navigate('/login');
}
}
return (
<div className="row justify-content-center">
<PageTitle titleKey="REGISTRATION.TITLE" />
<div className="col-md-8 col-lg-6">
<div className="card p-4">
<h5 className="card-title mb-1">{t('REGISTRATION.TITLE')}</h5>
<p className="text-muted small mb-3">{t('REGISTRATION.INTRO')}</p>
<form noValidate onSubmit={create}>
<PersonFields values={form} errors={submission.errors} onChange={edit} />
<h6 className="mt-4 text-muted">{t('PERSONS.ACCOUNT_SECTION')}</h6>
<InputField className="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" maxLength={30} autoComplete="username"
required value={form.login} onChange={(v) => edit('login', v)} error={submission.errors.login}
help="REGISTRATION.LOGIN_HELP" />
<div className="row g-3 mb-3">
<InputField className="col-sm-6" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" maxLength={72}
autoComplete="new-password" required value={form.password} onChange={(v) => edit('password', v)}
error={submission.errors.password} params={passwordParams} help="REGISTRATION.PASSWORD_HELP" />
<InputField className="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
maxLength={72} autoComplete="new-password" required value={form.confirmation}
onChange={(v) => edit('confirmation', v)} error={submission.errors.confirmation} />
</div>
<div className="d-flex gap-2">
<button type="submit" className="btn btn-primary" disabled={submission.submitting}>{t('REGISTRATION.SUBMIT')}</button>
<Link className="btn btn-secondary" to="/login">{t('REGISTRATION.BACK_TO_LOGIN')}</Link>
</div>
</form>
</div>
</div>
</div>
);
}
|
Erstellung eines Patientenkontos. Hier gelangen Sie nur weiter, nachdem Sie das CAPTCHA auf der Anmeldeseite eingegeben haben: Der Server hat einen Passierschein ausgestellt, den der Guard geprüft hat.
- Zeile 25: die Mindestlänge des Passworts für den Hilfetext („Mindestens 6 Zeichen.“). Der Server gibt sie auch zusammen mit dem Fehler [ERRORS.PASSWORD_TOO_SHORT] zurück;
- Zeile 35: die Parameter des Hilfetexts UND der Passwortfehler: Die Parameter des Servers haben, falls vorhanden, Vorrang;
- Zeilen 42–58: die Kontoerstellung:
- Zeile 52: Bei Erfolg Rückkehr zur Anmeldeseite mit vorausgefülltem Benutzernamen;
- Zeilen 53–57: Das Token ist abgelaufen (15 Minuten): Rückkehr zur Anmeldeseite für ein neues CAPTCHA.
10.4.10.7. src/pages/PatientArea.tsx
| // =========================================================================
// pages/PatientArea.tsx - "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 er einen hat, mit der Möglichkeit, ihn zu stornieren.
// Äquivalent zu views/patient/area.hbs der HTML-Anwendung.
// =========================================================================
import { Link } from 'react-router';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useTranslation } from 'react-i18next';
import { api } from '../api/rdvmedecins.api';
import { timeRange, longDate, label } from '../formatting';
import { useMessages } from '../stores/messages';
import { confirm } from '../stores/confirmation';
import PageTitle from '../components/PageTitle';
export default function PatientArea() {
const { t, i18n } = useTranslation();
const queryClient = useQueryClient();
const area = useQuery({ queryKey: ['my-area'], queryFn: api.myArea });
async function cancel(appointmentId: number) {
if (!(await confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
const messages = useMessages.getState();
try {
await api.cancelAppointment(appointmentId);
messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
messages.showApiError(e);
}
// der Bereich UND die Terminkalender haben sich geändert
await queryClient.invalidateQueries({ queryKey: ['my-area'] });
await queryClient.invalidateQueries({ queryKey: ['schedule'] });
}
const a = area.data;
if (!a) {
return (
<>
<PageTitle titleKey="AREA.TITLE" />
<p className="text-muted">{t('APP.LOADING')}</p>
</>
);
}
return (
<>
<PageTitle titleKey="AREA.TITLE" />
<h4 className="mb-3">{t('AREA.HELLO', { name: label(a.patient) })}</h4>
<div className="row g-3 mb-4">
<div className="col-sm-6">
<Link className="card p-4 h-100 text-decoration-none option-card" to="/my-account">
<h5 className="mb-1">{t('AREA.MANAGE_ACCOUNT')}</h5>
<span className="text-muted">{t('AREA.MANAGE_ACCOUNT_HELP')}</span>
</Link>
</div>
<div className="col-sm-6">
<Link className="card p-4 h-100 text-decoration-none option-card" to="/schedule">
<h5 className="mb-1">{t('AREA.VIEW_SCHEDULE')}</h5>
<span className="text-muted">{t('AREA.VIEW_SCHEDULE_HELP')}</span>
</Link>
</div>
</div>
<div className="card p-3">
<h5>{t('AREA.MY_APPOINTMENT')}</h5>
{/* normalerweise nur einer (Regel "ein bevorstehender Termin gleichzeitig"),
aber die Seite kann mehrere anzeigen */}
{a.appointments.map((appointment, i) => (
<div key={appointment.id} className={`d-flex flex-wrap justify-content-between align-items-center gap-2 py-2 ${i < a.appointments.length - 1 ? 'border-bottom' : ''}`}>
<div>
<div className="fw-semibold">{longDate(appointment.day, i18n.language)}, {timeRange(appointment.slot)}</div>
<div className="text-muted">
{label(appointment.doctor)} -{' '}
{/* der Terminkalender des Arztes an diesem Tag: Der Patient sieht darin seinen Namen */}
<Link to={`/schedule?${new URLSearchParams({ doctorId: String(appointment.doctor.id), day: appointment.day })}`}>
{t('AREA.SEE_IN_SCHEDULE')}
</Link>
</div>
</div>
<button type="button" className="btn btn-outline-danger" onClick={() => cancel(appointment.id)}>{t('AREA.CANCEL_APPOINTMENT')}</button>
</div>
))}
{a.appointments.length === 0 && <p className="text-muted mb-0">{t('AREA.NO_APPOINTMENT')}</p>}
</div>
</>
);
}
|
Die Startseite des Patienten: zwei Optionen, „Mein Konto verwalten“ und „Terminkalender anzeigen“, sowie sein bevorstehender Termin, den er stornieren kann.
- Zeile 22: der Patientenbereich. [queryFn: api.myArea]: die Funktion selbst, ohne sie in eine Arrow-Funktion zu verpacken; sie hat keine Parameter;
- Zeilen 24–38: Die Stornierung nach Bestätigung. Der Bereich UND die Terminkalender haben sich geändert: Beide werden invalidiert;
- Zeilen 41–48: Solange der Bereich nicht gelesen wurde: „Wird geladen …“;
- Zeilen 55–58: Eine ganze [Bootstrap]-Karte ist ein Link: [<Link>] akzeptiert beliebigen Inhalt;
- Zeilen 72–86: der bevorstehende Termin. Normalerweise nur einer (die Regel „ein bevorstehender Termin zur Zeit“), aber die Seite kann mehrere anzeigen;
- Zeile 79: ein Link zum Terminkalender des Arztes für diesen Tag, an dem der Patient seinen Namen sieht.
10.4.10.8. src/pages/MyAccount.tsx
| // =========================================================================
// pages/MyAccount.tsx - "Manage my account" (/my-account, Rolle USER)
// -------------------------------------------------------------------------
// Zwei unabhängige Formulare, wie views/patient/account.hbs:
// 1. die Aktualisierung (Identität, Login, optionales neues Passwort);
// 2. das Löschen des Kontos - das auch seine Termine storniert.
// Beide verlangen das AKTUELLE Passwort (vom Server geprüft).
// Zwei Formulare, also zwei Zustände und zwei useFormSubmit (zwei Sätze
// von Fehlern). Wie bei PersonForm wird das Aktualisierungsformular erst
// angezeigt, wenn das Konto gelesen wurde, und startet mit dessen Werten.
// =========================================================================
import { useState, type FormEvent } from 'react';
import { Link, useNavigate } from 'react-router';
import { useQuery, useQueryClient } from '@tanstack/react-query';
import { useTranslation } from 'react-i18next';
import { api } from '../api/rdvmedecins.api';
import type { MyAccountUpdate, MyAccount as Account } from '../api/types';
import { useSession } from '../stores/session';
import { useMessages } from '../stores/messages';
import { confirm } from '../stores/confirmation';
import { useFormSubmit } from '../hooks/useFormSubmit';
import PersonFields from '../components/PersonFields';
import InputField from '../components/InputField';
import PageTitle from '../components/PageTitle';
// -------------------------------------------------------------------------
// 1. die Aktualisierung
// -------------------------------------------------------------------------
function Update({ account }: { account: Account }) {
const { t } = useTranslation();
const navigate = useNavigate();
const queryClient = useQueryClient();
const submission = useFormSubmit();
const [form, setForm] = useState<MyAccountUpdate>({ ...account, password: '', confirmation: '', currentPassword: '' });
function edit(field: keyof MyAccountUpdate, value: string) {
setForm((f) => ({ ...f, [field]: value }));
submission.clearError(field);
}
async function save(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
const succeeded = await submission.submit(async () => {
// der Server hat ein NEUES Token ausgestellt (Name, Login): Die Navigations
// leiste muss folgen
useSession.getState().update(await api.editMyAccount(form));
useMessages.getState().flash('success', 'MY_ACCOUNT.UPDATED');
});
if (succeeded) {
await queryClient.invalidateQueries({ queryKey: ['my-area'] });
navigate('/my-area');
} else {
// nie ein Passwort im Feld belassen nach einem abgelehnten Absenden;
// der Wert wird OHNE den Umweg über edit() geändert, um den Fehler nicht zu löschen,
// den der Server soeben daran angehängt hat
setForm((f) => ({ ...f, currentPassword: '' }));
}
}
return (
<div className="card p-4 mb-4">
<h5 className="card-title mb-3">{t('MY_ACCOUNT.TITLE')}</h5>
<form noValidate onSubmit={save}>
<PersonFields values={form} errors={submission.errors} onChange={edit} />
<h6 className="mt-4 text-muted">{t('PERSONS.ACCOUNT_SECTION')}</h6>
<InputField className="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" maxLength={30} autoComplete="username"
required value={form.login} onChange={(v) => edit('login', v)} error={submission.errors.login} />
<div className="row g-3 mb-3">
<InputField className="col-sm-6" fieldId="password" type="password" label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
maxLength={72} autoComplete="new-password" value={form.password}
onChange={(v) => edit('password', v)} error={submission.errors.password} params={submission.params}
help="PERSONS.PASSWORD_HELP_EDIT" />
<InputField className="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
maxLength={72} autoComplete="new-password" value={form.confirmation}
onChange={(v) => edit('confirmation', v)} error={submission.errors.confirmation} />
</div>
<InputField className="mb-4" fieldId="currentPassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
maxLength={72} autoComplete="current-password" required value={form.currentPassword}
onChange={(v) => edit('currentPassword', v)} error={submission.errors.currentPassword}
help="MY_ACCOUNT.CURRENT_PASSWORD_HELP" />
<div className="d-flex gap-2">
<button type="submit" className="btn btn-primary" disabled={submission.submitting}>{t('PERSONS.SAVE')}</button>
<Link className="btn btn-secondary" to="/my-area">{t('MY_ACCOUNT.BACK')}</Link>
</div>
</form>
</div>
);
}
// -------------------------------------------------------------------------
// 2. das Löschen: ein Formular mit einem einzigen Feld
// -------------------------------------------------------------------------
function Deletion() {
const { t } = useTranslation();
const navigate = useNavigate();
const submission = useFormSubmit();
const [currentPassword, setCurrentPassword] = useState('');
async function remove(e: FormEvent<HTMLFormElement>) {
e.preventDefault();
if (!(await confirm('MY_ACCOUNT.DELETE_CONFIRM'))) {
return;
}
const succeeded = await submission.submit(() => api.deleteMyAccount(currentPassword));
if (succeeded) {
useSession.getState().forget(); // der Server hat das Token-Cookie gelöscht
useMessages.getState().flash('success', 'MY_ACCOUNT.DELETED');
navigate('/login');
}
}
return (
<div className="card p-4 border-danger">
<h5 className="card-title text-danger mb-1">{t('MY_ACCOUNT.DELETE_TITLE')}</h5>
<p className="text-muted small">{t('MY_ACCOUNT.DELETE_HELP')}</p>
<form className="d-flex flex-wrap gap-2 align-items-end" noValidate onSubmit={remove}>
<InputField className="flex-grow-1" fieldId="deletePassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
maxLength={72} autoComplete="current-password" required value={currentPassword}
onChange={(v) => {
setCurrentPassword(v);
submission.clearError('currentPassword');
}}
error={submission.errors.currentPassword} />
<button type="submit" className="btn btn-danger" disabled={submission.submitting}>{t('MY_ACCOUNT.DELETE_SUBMIT')}</button>
</form>
</div>
);
}
// -------------------------------------------------------------------------
// die Seite
// -------------------------------------------------------------------------
export default function MyAccount() {
const { t } = useTranslation();
// gcTime: 0: bei jedem Besuch erneut gelesen (seine Version muss aktuell sein)
const account = useQuery({ queryKey: ['my-account'], queryFn: api.myAccount, gcTime: 0 });
return (
<div className="row justify-content-center">
<PageTitle titleKey="MY_ACCOUNT.TITLE" />
<div className="col-md-8 col-lg-6">
{account.data ? <Update account={account.data} /> : <p className="text-muted">{t('APP.LOADING')}</p>}
<Deletion />
</div>
</div>
);
}
|
Zwei unabhängige Formulare und damit zwei Komponenten, jede mit ihrem eigenen Zustand und [useFormSubmit] (zwei Fehlermengen):
- Zeilen 30–90: Änderung von Identität, Login und optional des Passworts:
- Zeile 35: Das Formular beginnt mit den Werten des Kontos (einschließlich seiner Version), wobei die Passwortfelder leer sind;
- Zeile 47: Der Server hat ein NEUES Token mit dem neuen Namen und dem neuen Login ausgestellt und leitet den Benutzer weiter: Es wird im Sitzungs-Store gespeichert, und die Navigationsleiste aktualisiert sich entsprechend;
- Zeilen 53–58: Eine Übermittlung wurde abgelehnt: Ein Passwort darf nie in einem Feld stehen bleiben. Wir ändern den Wert OHNE den Umweg über [edit()], um den Fehler nicht zu löschen, den der Server dem Feld gerade zugeordnet hat;
- Zeilen 95–130: Löschen des Kontos, wodurch auch seine Termine storniert werden:
- Zeile 99: ein Formular mit einem einzigen Feld: ein einzelner String;
- Zeilen 107–111: Das Konto ist gelöscht, und der Server hat das Token-Cookie gelöscht: Der Client vergisst den Benutzer, dann folgt die Anmeldeseite zusammen mit der Meldung;
- Zeilen 135–149: die Seite. [gcTime: 0]: Das Konto wird bei jedem Besuch neu gelesen; seine Version muss aktuell sein. Das Löschen wird sofort angezeigt; die Änderung, sobald das Konto gelesen wurde.
10.4.10.9. src/pages/ErrorPage.tsx
| // =========================================================================
// pages/ErrorPage.tsx - die Fehlerseite: 404 (unbekannte Adresse) oder 403
// (unzureichende Rolle, siehe guards.ts). Äquivalent zu views/error.hbs.
// =========================================================================
import { Link } from 'react-router';
import { useTranslation } from 'react-i18next';
import PageTitle from '../components/PageTitle';
export default function ErrorPage({ code }: { code: 403 | 404 }) {
const { t } = useTranslation();
return (
<div className="card p-4">
<PageTitle titleKey="ERROR_PAGE.TITLE" />
<h4 className="text-danger">{t('ERROR_PAGE.TITLE')} {code}</h4>
<p>{t(code === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND')}</p>
<Link to="/" className="btn btn-primary align-self-start">{t('ERROR_PAGE.BACK')}</Link>
</div>
);
}
|
Fehlerseite: 404 (unbekannte Adresse) oder 403 (unzureichende Berechtigungen). [code: 403 | 404]: Diese Property kann nur diese beiden Werte annehmen.