Skip to content

6. Kapitel 5 - Der [React]-Client für die Anwendung [RdvMedecins]

Dieses Kapitel beschreibt Datei für Datei den Inhalt des diesem Dokument beiliegenden Ordners [rdvmedecins-react-client] im im gesamten Kurs verwendeten Format: zeilenweise nummerierter Quellcode, gefolgt von einem Abschnitt „Kommentieren wir diesen Code:“. Jeder Ordner des Projekts enthält außerdem eine eigene [README.md].

6.1. Architekturüberblick

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

Image

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

Wie im ursprünglichen Dokument kommunizieren Komponenten NIEMALS direkt mit dem Server: Diese Rolle ist ausschließlich der Services-Schicht vorbehalten (hier der Hook useAppointmentService() und der Context AuthContext). Dies ist ein Entwurfsprinzip, das für AngularJS 1.x ebenso gilt wie für [Angular] und [React] – es hat sich nicht geändert.

6.2. Projektbaum

Image

Image

Diese Aufteilung folgt direkt dem Ablauf des ursprünglichen Dokuments (Login, Auswahl von Arzt/Tag, Anzeige des Terminkalenders, Reservierung), hier lediglich in funktionalen [React] -Komponenten organisiert statt in getrennten Controllern/Views von AngularJS 1.x oder in Standalone-Komponenten von [Angular]. Gegenüber der [Angular]-Verzeichnisstruktur dieses Kurses gibt es zwei strukturelle Unterschiede:

  • Die Wurzelkomponente besteht aus drei Dateien (App.tsx, App.css, README.md) statt aus fünf (app.ts, app.html, app.css, app.config.ts, app.routes.ts): [JSX] verschmilzt Klasse und Template, und [React] hat keine Konfigurationsdatei für die Anwendung, die app.config.ts entspricht (siehe „Konfiguration der Anwendung“ weiter unten);
  • Es erscheint ein Ordner `core/context/` , der in der [Angular]-Variante fehlt: Er enthält die Custom Hooks und die [React]-[Context]-Dateien , die als injizierbare Services ([SettingsService], [AuthService], [LanguageService]) der [Angular]-Variante dienen – dieser Mechanismus (Hooks + [Context]) wurde im vorherigen Kapitel zusammen mit einem generischen Beispiel vorgestellt (siehe vorheriges Kapitel, „Logik gemeinsam nutzen“).

[Bootstrap] 5 wird in allen Views verwendet (in main.tsx importiert; siehe unten) – eine direkte Weiterentwicklung von Bootstrap 3, das bereits das ursprüngliche Dokument verwendete, und unverändert gegenüber der [Angular]-Variante dieses Kurses.

6.3. Konfigurationsdateien des Projekts

Image

6.3.1. package.json

{
  "name": "rdvmedecins-react-client",
  "version": "0.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "dev": "vite",
    "start": "vite",
    "build": "tsc -b && vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "i18next": "^25.0.0",
    "i18next-http-backend": "^3.0.0",
    "react": "^19.1.0",
    "react-dom": "^19.1.0",
    "react-i18next": "^15.0.0",
    "bootstrap": "^5.3.3"
  },
  "devDependencies": {
    "@types/react": "^19.1.0",
    "@types/react-dom": "^19.1.0",
    "@vitejs/plugin-react": "^5.0.0",
    "typescript": "~5.9.0",
    "vite": "^6.4.0"
  }
}

Kommentieren wir diesen Code:

  • Zeile 5: "type": "module", — teilt Node mit, dass dieses Projekt nativ die ECMAScript-Module (import/export) ohne vorherige Transformation verwendet – eine Einstellung, die auch ein [Angular] -CLI-Projekt implizit in seinem eigenen Werkzeugsatz definiert;
  • Zeilen 6–11: "scripts": { … } — die verfügbaren Befehle [npm run <name>]. [start] (wie `dev`) startet den [Vite]-Entwicklungsserver mit automatischem Neuladen, sobald eine Quelldatei geändert wird ([Vite] bezeichnet diesen Mechanismus als Hot Module Replacement) – dies ist der im gesamten Dokument verwendete Befehl, auf Port 4200 (siehe [vite.config.ts] weiter unten), demselben Port wie bei der [Angular]-Variante dieses Kurses;
  • Zeilen 12–19: "dependencies": { … } — die Pakete, die zum Ausführen der Anwendung im Browser erforderlich sind: [react]/[react-dom] (der Kern von [React] und seine Integration in das DOM des Browsers), [Bootstrap] (nur das Stylesheet) und – in diesem Kapitel hinzugefügt – [i18next]/[i18next-http-backend]/[react-i18next], die Drittanbieterbibliothek für die Übersetzung der Oberfläche FR/EN (siehe i18n.ts und core/context/language.context.tsx weiter unten). Anders als in der [Angular]-Variante dieses Kurses gibt es kein Äquivalent zu [@angular/router] (keinen Router; siehe vorheriges Kapitel) und auch keines zu RxJS ([fetch] gibt direkt ein Promise zurück; siehe vorheriges Kapitel);
  • Zeilen 20–26: "devDependencies": { … } — Pakete, die nur während der Entwicklung benötigt werden und nie im an den Browser ausgelieferten finalen Bundle enthalten sind: die Typen von TypeScript und [React] ([@types/react], [@types/react-dom] – [React] selbst ist in JavaScript geschrieben, nicht in TypeScript, anders als [Angular]), [@vitejs/plugin-react] (die Umwandlung von [JSX] in JavaScript sowie Fast Refresh während der Entwicklung), TypeScript und [Vite] selbst.

Anders als der [NestJS]-Server (Modul [commonjs], siehe Kapitel 3) läuft dieses Projekt auf nativen ECMAScript-Modulen (import/export) – genau wie die [Angular]-Variante dieses Kurses (“module”: “preserve” in tsconfig.json, siehe unten).

6.3.2. vite.config.ts

1
2
3
4
5
6
7
8
9
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [react()],
  server: {
    port: 4200,
  },
});

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 5: plugins: [react()], — aktiviert die Umwandlung von [JSX]/[TSX] und das Hot Reloading – das Äquivalent dessen, was @angular/build:dev-server für [React] im Hintergrund für [Angular] leistet (siehe angular.json der [Angular]-Variante dieses Kurses);
  • Zeilen 6–8: server: { port: 4200, }, — setzt den Port des Entwicklungsservers auf 4200, denselben wie [ng serve] auf der [Angular]-Seite – eine rein didaktische Entscheidung, damit die beiden Varianten dieses Kurses austauschbar bleiben, ohne dass Sie Ihren Arbeitsablauf ändern müssen.

Diese Datei hat kein Äquivalent im ursprünglichen AngularJS-1.x-Projekt (die damaligen Build-Werkzeuge – Grunt, Gulp – wurden separat konfiguriert); auf der [Angular]-Seite dieses Kurses erfüllt [angular.json] diesen Zweck; auf der [NestJS]-Seite (Kapitel 3) ist es [nest-cli.json].

6.3.3. tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "preserve",
    "jsx": "react-jsx",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "skipLibCheck": true,
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true
  },
  "include": ["src"]
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 5: "jsx": "react-jsx", — teilt dem TypeScript-Compiler mit, wie das [JSX] umzuwandeln ist; [react-jsx] ist die moderne Einstellung (seit React 17), die es überflüssig macht, [import React from 'react'] in jeder .tsx-Datei zu schreiben, die [JSX] verwendet – eine kleine Vereinfachung gegenüber den allerersten [React]-Projekten;
  • Zeile 6: "strict": true, — wie die [tsconfig.json] in der [Angular]-Variante dieses Kurses ist der vollständige Strict-Modus von TypeScript aktiviert: Jede Variable muss einen bestimmbaren Typ haben, und jeder null- oder undefined-Wert muss explizit behandelt werden;
  • Zeilen 7–8: "noUnusedLocals": true, "noUnusedParameters": true, — markiert bei der Kompilierung jede Variable oder jeden Parameter, die deklariert, aber nie verwendet werden – eine Einstellung, die die [Angular]-Variante dieses Kurses nicht ausdrücklich aktiviert (der [Angular]-Compiler hat über strictTemplates eigene, andere Prüfungen) ;
  • Zeile 14: "noEmit": true — TypeScript wird hier ausschließlich zur Typ-PRÜFUNG verwendet ([npm run build] führt zuerst `tsc -b` aus, was fehlschlägt, wenn ein Typfehler vorliegt): Es ist [Vite] (über esbuild), das tatsächlich das vom Browser ausgeführte JavaScript erzeugt, nicht der TypeScript-Compiler selbst – ein bemerkenswerter Unterschied zu [Angular] (ngc), das selbst das finale JavaScript erzeugt.

Während die [Angular]-Variante dieses Kurses [tsconfig.json] (gemeinsame Basis) und [tsconfig.app.json] (über den Mechanismus der Projektreferenzen) trennt, besteht dieses kleinere [React]-Projekt aus einer einzigen Datei – da die Typprüfungen für die Templates ([Angular] und strictTemplates) hier ohnehin kein Äquivalent haben: Der TypeScript-Compiler selbst prüft [JSX], genau wie jede andere .tsx-Datei.

6.4. Start der Anwendung

Image

6.4.1. index.html

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="icon" type="image/x-icon" href="/favicon.ico" />
    <title>RdvMedecins - React client</title>
  </head>
  <body>
    <div id="root"></div>
    <script type="module" src="/src/main.tsx"></script>
  </body>
</html>

Kommentieren wir diesen Code:

  • Zeile 2: <html lang="en"> — wie bei [Angular] kann diese Seite (HTML), da sie statisch ist (vom Browser geladen, BEVOR die [React]-Anwendung überhaupt startet), eine später vom Benutzer getroffene Sprachauswahl nicht sofort widerspiegeln;
  • Zeile 10: <div id="root"></div> — das einzige Element, das diese Seite anfangs enthält und das [React] nach dem Start vollständig füllt (siehe [main.tsx] weiter unten) – das genaue Äquivalent zu <app-root></app-root> auf der [Angular]-Seite und zu [ng-app="rdvmedecinsApp"] am Tag <html> des ursprünglichen Dokuments (AngularJS 1.x, 2014);
  • Zeile 11: <script type="module" src="/src/main.tsx"></script> — erster bemerkenswerter Unterschied zur [Angular]-Variante dieses Kurses: Hier verweist index.html direkt auf main.tsx (eine für [Vite] spezifische Konvention) und nicht umgekehrt (ein vorkompiliertes JavaScript-Bundle, das beim Build von [Angular] in die Seite eingefügt wird). Während der Entwicklung [Vite] transformiert und liefert diese .tsx-Datei im laufenden Betrieb aus; in der Produktion (npm run build) wird sie selbstverständlich vorher kompiliert.

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

6.4.2. src/main.tsx

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { SettingsProvider } from './app/core/context/settings.context';
import { AuthProvider } from './app/core/context/auth.context';
import { LanguageProvider } from './app/core/context/language.context';
import { App } from './app/App';
import 'bootstrap/dist/css/bootstrap.min.css';
import './index.css';
import './i18n';

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <SettingsProvider>
      <AuthProvider>
        <LanguageProvider>
          <App />
        </LanguageProvider>
      </AuthProvider>
    </SettingsProvider>
  </StrictMode>,
);

Kommentieren wir diesen Code:

  • Zeile 11: createRoot(document.getElementById('root')!).render(…) — das direkte Äquivalent zu bootstrapApplication(App, appConfig) auf der [Angular]-Seite: Es startet die Anwendung im Element #root von index.html. Das Ausrufezeichen (!) teilt TypeScript mit, dass wir sicher sind, dass dieses Element existiert (es wird in Zeile 10 von [index.html] definiert);
  • Zeilen 13–19: <SettingsProvider><AuthProvider><LanguageProvider><App /></LanguageProvider></AuthProvider></SettingsProvider> — die drei Provider aus core/context/ (siehe unten) umschließen die Wurzelkomponente [App]: Dadurch lassen sich useSettings(), useAuth() und useLanguage() aus jeder nachgeordneten Komponente verwenden – das Äquivalent der drei provideXxx() in [app.config.ts] auf der [Angular]-Seite (providers: [...]), hier aber als Verschachtelung von Komponenten statt als Liste ausgedrückt;
  • Zeile 7: import 'bootstrap/dist/css/bootstrap.min.css'; — [Vite] erlaubt es, ein Stylesheet direkt aus einer TypeScript-Datei zu importieren; bei [Angular] übernimmt dies angular.json (Array styles: [...]) – gleiches Ergebnis, anderer Mechanismus;
  • Zeile 9: import './i18n'; — wird allein wegen seines Seiteneffekts importiert (Initialisierung von [i18next]; siehe i18n.ts weiter unten): Nichts aus diesem Import wird verwendet, aber seine Ausführung ist nötig, bevor [useTranslation()] in den Komponenten funktioniert.

<StrictMode> ist eine für [React] spezifische Komponente, die nur die Entwicklung betrifft (in der Produktion ohne Wirkung): Sie hilft, bestimmte fehlerhaft geschriebene Seiteneffekte zu erkennen, indem sie bestimmte Renderings doppelt ausführt – es gibt kein direktes Äquivalent in [Angular], wo der Compiler solche Fehler stattdessen zur Kompilierzeit erkennt.

6.4.3. src/i18n.ts

import i18n from 'i18next';
import { initReactI18next } from 'react-i18next';
import HttpBackend from 'i18next-http-backend';

i18n
  .use(HttpBackend)
  .use(initReactI18next)
  .init({
    lng: navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : 'en',
    fallbackLng: 'en',
    interpolation: {
      escapeValue: false,
    },
    backend: {
      loadPath: '/i18n/{{lng}}.json',
    },
  });

export default i18n;

Kommentieren wir diesen Code:

  • Zeile 6: .use(HttpBackend) — lädt jedes Wörterbuch über eine HTTP-GET-Anfrage an die URL, die aus [backend.loadPath] gebildet wird (Zeile 15): [/i18n/fr.json] oder [/i18n/en.json], GENAU dieselbe URL wie die, die [TranslateHttpLoader] auf der [Angular]-Seite bildet (prefix: '/i18n/', suffix: '.json'), sodass [public/i18n/fr.json] und [public/i18n/en.json] (siehe unten) unverändert wiederverwendet werden können;
  • Zeile 7: .use(initReactI18next) — verbindet [i18next] mit [React]: Es stellt den Hook useTranslation() bereit, der in jeder Komponente in features/ verwendet wird, sowie den React-[Context] (intern in der Bibliothek, hier nicht sichtbar), der bei einem Sprachwechsel ein vollständiges erneutes Rendern der gesamten Oberfläche auslöst – das Äquivalent dessen, was auf der [Angular]-Seite der [TranslatePipe]-Dekorator in Kombination mit [provideTranslateService(...)] leistet;
  • Zeile 9: lng: navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : 'en', — Startsprache (Französisch, wenn der Browser auf Französisch eingestellt ist, sonst Englisch; fallbackLng: 'en' in Zeile 10); der Hook [useLanguage()] (siehe core/context/language.context.tsx weiter unten) ersetzt sie sofort durch die in localStorage gespeicherte Auswahl, falls vorhanden – genau wie lang: 'en' in [app.config.ts] auf der [Angular]-Seite;
  • Zeilen 11–13: interpolation: { escapeValue: false, }, — [React] maskiert HTML bereits selbst (Schutz vor XSS-Schwachstellen): [i18next] muss dies nicht ein zweites Mal tun.

Im ursprünglichen Dokument (2014) stützte sich der AngularJS-1.x-Client für denselben Bedarf auf die Bibliothek angular-translate – den Vorgänger, innerhalb des AngularJS-1.x-Ökosystems, von [@ngx-translate/core] (der [Angular]-Variante dieses Kurses) und, hier, von [i18next]. Die BEIDEN modernen Bibliotheken ([ngx-translate] auf der [Angular]-Seite, [i18next] auf der [React]-Seite) laden JSON-Wörterbücher über eine einfache HTTP-GET-Anfrage, nach demselben Schema „eine Datei pro Sprache, ein Abschnitt pro Bildschirm“.

6.4.4. src/index.css

1
2
3
4
5
6
7
body {
  background-color: #f5f7fa;
}

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

Kommentieren wir diesen Code:

  • Zeile 1: body { background-color: #f5f7fa; } — unverändert aus src/styles.css der [Angular]-Seite übernommen: ein sehr helles Grau statt des standardmäßigen reinen Weiß, damit sich die [Bootstrap]-Karten (weißer Hintergrund, .card) leicht vom Seitenhintergrund abheben;
  • Zeilen 5–7: .free-slot:hover — wird auf die Zeilen der Kalendertabelle angewendet, die ein freies Zeitfenster darstellen (siehe Schedule.tsx, className={scheduleSlot.appointment === null ? 'free-slot' : undefined}, später besprochen): Der Hintergrund färbt sich beim Überfahren leicht grün. Der Handcursor (cursor: pointer, wie in [Angular] gezeigt) wird direkt auf die Schaltfläche „Reservieren“ selbst angewendet (ein echter <button>), nicht auf die gesamte Tabellenzeile.

Diese Datei enthält globale Stile, im Gegensatz zu den „lokalen“ Stilen, die in der .css-Datei jeder Komponente definiert sind (login.css, schedule.css …) und nur für das [JSX] dieser jeweiligen Komponente gelten – dasselbe Prinzip wie in [Angular] (CSS-Dateien pro Komponente). App.css, das Stylesheet der Wurzelkomponente, bleibt leer: [Bootstrap] und index.css genügen für alles, was dieses Dokument umsetzt.

6.5. Die Schicht core/models

Image

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

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

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

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

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

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

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

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

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

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

Kommentieren wir diesen Code:

  • Diese Datei ist ein direktes Kopieren und Einfügen der gleichnamigen Datei der [Angular]-Variante dieses Kurses: Die TypeScript-Interfaces, die die mit dem Server ausgetauschten Daten beschreiben, hängen von keiner Oberflächenbibliothek ab, weder von [React] noch von [Angular] – es ist „reines“ TypeScript, das Begriff für Begriff der Klasse [ServerResponse]<T> und den [TypeORM]-Entitäten des [NestJS]-Servers entspricht (Kapitel 3);
  • [Client] bezeichnet hier – wie auf der [Angular]-Seite und im ursprünglichen Dokument – einen PATIENTEN der Arztpraxis, nicht zu verwechseln mit „HTTP-Client“;
  • Role / LoginResult — originalgetreue Kopien der gleichnamigen Server-Typen (src/entities/user.entity.ts, auth/login-result.model.ts, Kapitel 3).

In AngularJS 1.x (2014) erlaubte das reine JavaScript es nicht, das erwartete Datenformat auf diese Weise zu beschreiben. Mit TypeScript – das sowohl von [Angular] als auch von [React] verwendet wird – wird ein Tippfehler in einem Feldnamen bereits vor der Ausführung des Programms, direkt zur Kompilierzeit, gemeldet.

6.6. Die Schicht core/context

Image

Dieser Ordner hat kein Äquivalent in der [Angular]-Variante dieses Kurses (siehe vorheriges Kapitel, „Logik gemeinsam nutzen“): Er vereint die drei [React]-[Context]s, die in diesem Zusammenhang die Rolle der injizierbaren Services ([SettingsService], [AuthService] und eines Teils von [LanguageService]) auf der [Angular]-Seite übernehmen.

6.6.1. src/app/core/context/settings.context.tsx

import { createContext, useContext, useState, type ReactNode } from 'react';

interface SettingsContextValue {
  apiBaseUrl: string;
  setApiBaseUrl: (url: string) => void;
}

const SettingsContext = createContext<SettingsContextValue | null>(null);

export function SettingsProvider({ children }: { children: ReactNode }) {
  const [apiBaseUrl, setApiBaseUrl] = useState('http://localhost:8080');
  return (
    <SettingsContext.Provider value={{ apiBaseUrl, setApiBaseUrl }}>
      {children}
    </SettingsContext.Provider>
  );
}

export function useSettings(): SettingsContextValue {
  const context = useContext(SettingsContext);
  if (context === null) {
    throw new Error('useSettings() must be called under a <SettingsProvider>');
  }
  return context;
}

Kommentieren wir diesen Code:

  • Zeile 11: const [apiBaseUrl, setApiBaseUrl] = useState('http://localhost:8080'); — ersetzt [readonly apiBaseUrl = signal('http://localhost:8080');] exakt wie [SettingsService] auf der [Angular]-Seite: derselbe Standardwert, dieselbe Möglichkeit, ihn über das Feld „Server-URL“ in der Startansicht des ursprünglichen Dokuments zu ändern;
  • Zeilen 12–16: <SettingsContext.Provider value={{ apiBaseUrl, setApiBaseUrl }}>{children}</SettingsContext.Provider> — veröffentlicht das Paar (Wert, Setter) an alle Nachkommen, genau die Rolle, die [providedIn: 'root'] auf der [Angular]-Seite spielte;
  • Zeilen 19–25: export function useSettings(): SettingsContextValue { — der Hook, den die Komponenten aufrufen (const settings = useSettings();), ein direktes Äquivalent zu inject(SettingsService).

6.6.2. src/app/core/context/auth.context.tsx

Port von [AuthService]: verwaltet die Anmeldung des Benutzers, ruft [POST /login] auf, speichert den erhaltenen JWT-Token (und die zugehörige Identität/Rolle) und stellt mithilfe von [localStorage] sicher, dass er ein Neuladen der Seite übersteht. Dies ist neben [useAppointmentService()] (siehe unten) die einzige Stelle der Anwendung, die per HTTP mit dem Server kommuniziert.

import { createContext, useContext, useMemo, useState, type ReactNode } from 'react';
import type { LoginResult, ServerResponse, Role } from '../models/appointment.models';
import { useSettings } from './settings.context';

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

const STORAGE_KEY = 'rdvmedecins.session';

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

interface AuthContextValue {
  isLoggedIn: boolean;
  login: string | null;
  name: string | null;
  role: Role | null;
  isAdmin: boolean;
  accessToken: string | null;
  logIn: (login: string, password: string) => Promise<LoginResult>;
  logOut: () => void;
}

const AuthContext = createContext<AuthContextValue | null>(null);

export function AuthProvider({ children }: { children: ReactNode }) {
  const { apiBaseUrl } = useSettings();
  const [session, setSession] = useState<StoredSession | null>(readStoredSession);

  async function logIn(login: string, password: string): Promise<LoginResult> {
    const httpResponse = await fetch(`${apiBaseUrl}/login`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ login, password }),
    });
    const envelope = (await httpResponse.json()) as ServerResponse<LoginResult>;
    if (envelope.status !== 0 || envelope.data === null) {
      throw new Error('Login failed');
    }
    const result = envelope.data;
    setSession(result);
    localStorage.setItem(STORAGE_KEY, JSON.stringify(result));
    return result;
  }

  function logOut(): void {
    setSession(null);
    localStorage.removeItem(STORAGE_KEY);
  }

  const value = useMemo<AuthContextValue>(
    () => ({
      isLoggedIn: session !== null,
      login: session?.login ?? null,
      name: session?.name ?? null,
      role: session?.role ?? null,
      isAdmin: session?.role === 'ADMIN',
      accessToken: session?.accessToken ?? null,
      logIn,
      logOut,
    }),
    [session, apiBaseUrl],
  );

  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
}

export function useAuth(): AuthContextValue {
  const context = useContext(AuthContext);
  if (context === null) {
    throw new Error('useAuth() must be called under an <AuthProvider>');
  }
  return context;
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeilen 14–21: function readStoredSession(): StoredSession | null { — durch einen try/catch-Block geschützt, genau wie auf der [Angular]-Seite: [localStorage] kann nicht verfügbar sein (sehr restriktives privates Surfen) oder einen beschädigten Wert enthalten – in diesem Fall nehmen wir einfach an, dass es keine Sitzung gibt;
  • Zeile 38: const [session, setSession] = useState<StoredSession | null>(readStoredSession); — [useState(function)] führt diese Funktion nur EINMAL aus, beim allerersten Rendering (nicht bei jedem Rendering): genau die Rolle, die der Initialisierer [signal(readStoredSession())] auf der [Angular]-Seite spielt. Lädt der Benutzer die Seite nach der Anmeldung neu, bleibt er angemeldet;
  • Zeilen 40–54: async function logIn(login: string, password: string): Promise<LoginResult> { — entspricht [POST /login, JSON body { login, password }]; anders als [AuthService.logIn()] auf der [Angular]-Seite (die ein Observable zurückgibt und die Sitzung in einem separaten tap()-Operator speichert) verkettet die Version mit [fetch]/async-await die Schritte ganz natürlich von oben nach unten, ohne einen eigenen Operator;
  • Zeilen 56–59: function logOut(): void { – rein lokal (kein Serveraufruf): Ein JWT-Token wird in dieser Portierung serverseitig nicht „widerrufen“; es läuft von selbst nach JWT_EXPIRES_IN ab (siehe die .env des Servers, Kapitel 3);
  • Zeilen 61–73: const value = useMemo<AuthContextValue>(() => ({ … }), [session, apiBaseUrl]); – [useMemo]() verhindert, dass bei jedem Rendern von [AuthProvider] ein neues `value`-Objekt erzeugt wird, solange sich weder [session] noch [apiBaseUrl] geändert hat: Ohne diesen Aufruf würde jede Komponente, die [useAuth()] verwendet, bei jedem Rendern von [AuthProvider] unnötigerweise neu gezeichnet – ein Performanceproblem, das auf der Seite von [Angular] keine direkte Entsprechung hat, da `computed()` dort ohnehin nur neu berechnet, was tatsächlich von einem geänderten Signal abhängt.

6.6.3. src/app/core/context/language.context.tsx

Portierung eines Teils von [LanguageService]: zentralisiert den Wechsel der Oberflächensprache (Französisch/Englisch) auf Basis des [useTranslation()]-Hooks, den [react-i18next] bereitstellt.

// src/app/core/context/language.context.tsx

import { createContext, useContext, useEffect, type ReactNode } from 'react';
import { useTranslation } from 'react-i18next';

const STORAGE_KEY = 'rdvmedecins.language';

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

interface LanguageContextValue {
  currentLanguage: Language;
  changeLanguage: (language: Language) => void;
}

const LanguageContext = createContext<LanguageContextValue | null>(null);

export function LanguageProvider({ children }: { children: ReactNode }) {
  const { i18n } = useTranslation();

  useEffect(() => {
    const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null;
    if (savedLanguage && savedLanguage !== i18n.language) {
      i18n.changeLanguage(savedLanguage);
      document.documentElement.lang = savedLanguage;
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, []);

  function changeLanguage(language: Language): void {
    localStorage.setItem(STORAGE_KEY, language);
    i18n.changeLanguage(language);
    document.documentElement.lang = language;
  }

  const value: LanguageContextValue = {
    currentLanguage: i18n.language as Language,
    changeLanguage,
  };

  return <LanguageContext.Provider value={value}>{children}</LanguageContext.Provider>;
}

export function useLanguage(): LanguageContextValue {
  const context = useContext(LanguageContext);
  if (context === null) {
    throw new Error('useLanguage() must be called under a <LanguageProvider>');
  }
  return context;
}

Kommentieren wir diesen Code:

  • Zeile 18: const { i18n } = useTranslation(); – [react-i18next] stellt die i18n-Instanz (und deren aktuelle Sprache, i18n.language) über diesen Hook bereits bereit: Anders als bei [SettingsContext]/[AuthContext] muss dafür kein eigener Zustand angelegt werden; das ist dasselbe Konzept wie bei [Angular], wo LanguageService this.translate.currentLang lediglich unter einem anderen Namen erneut veröffentlicht;
  • Zeilen 20–27: useEffect(() => { … }, []); – ein leeres Abhängigkeits-Array ([]) bedeutet „diesen Effekt nur ein einziges Mal ausführen, wenn die Komponente eingehängt wird“ – die direkte Entsprechung des constructor() von [LanguageService] auf der Seite von [Angular]: Hatte der Benutzer bei einem früheren Besuch bereits eine Sprache gewählt, wird sie wiederhergestellt; andernfalls wird die in [i18n.ts] festgelegte Standardsprache (Englisch, bzw. Französisch bei einem französischen Browser) verwendet;
  • Zeilen 29–33: function changeLanguage(language: Language): void { – wird von den beiden Schaltflächen FR/EN in der Navigationsleiste aufgerufen (siehe [App.tsx] weiter unten); [i18n.changeLanguage(...)] lädt (falls nötig) die entsprechende Datei [public/i18n/<language>.json] und wechselt dann die aktuelle Sprache – anders als [translate.use(language)] auf der Seite von [Angular] (ein Observable, siehe vorheriges Kapitel) entscheidet sich der Code hier dafür, nicht auf das Promise zu warten (es wird sehr schnell aufgelöst, da die Datei nach dem allerersten Laden im Cache liegt);
  • Zeile 32: document.documentElement.lang = language; – aktualisiert das Attribut <html lang="..."> der Seite (nützlich für die Barrierefreiheit), das keine der beiden Bibliotheken von sich aus pflegt, da [index.html] eine statische Seite ist, die schon vor dem Start der Anwendung geladen wird – exakt dieselbe Anforderung und dieselbe Lösung wie bei [Angular].

Entspricht der Schaltfläche „FR / EN“ im ursprünglichen AngularJS-1.x-Client, der damals auf der Bibliothek [angular-translate] beruhte – dem Vorläufer von [ngx-translate] ([Angular]) und später von [i18next] ([React]) innerhalb des AngularJS-1.x-Ökosystems.

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

Image

[i18next-http-backend] (konfiguriert in i18n.ts, siehe oben) lädt eine dieser beiden Dateien über eine Anfrage [HTTP GET /i18n/<language>.json], sobald die Sprache wechselt (oder erstmals verwendet wird). [react-i18next] löst dann jeden Schlüssel ("LOGIN.TITLE", "SCHEDULE.FREE" …) über den [useTranslation() (function t(...))]-Hook auf, der in allen Komponenten im Verzeichnis features/ verwendet wird (siehe weiter unten in diesem Kapitel).

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / React",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "...": "..."
  },
  "DOCTOR_DAY_PICKER": { "...": "..." },
  "SCHEDULE": { "...": "..." },
  "BOOKING_DIALOG": { "...": "..." }
}

Kommentieren wir diesen Code:

  • Diese Datei wird unverändert aus der [Angular]-Variante dieses Kurses übernommen (gleiche Schlüssel, gleiche Texte), mit einer Ausnahme: Zeile 3, ["TITLE"], verweist nun auf [React] statt auf [Angular] – der einzige Unterschied zwischen den beiden Clients, der sich tatsächlich auf den dem Benutzer angezeigten Text auswirkt;
  • ein verschachteltes JSON-Objekt mit einem Abschnitt pro Komponente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); [i18next] macht daraus ein flaches Wörterbuch, in dem sich jeder vollständige Schlüssel ("LOGIN.TITLE") durch Verkettung des Pfads mit Punkten ergibt – genau wie bei [TranslateService] in [Angular].

6.7.2. public/i18n/en.json

1
2
3
4
5
6
{
  "APP": {
    "TITLE": "RdvMedecins - NestJS / React port",
    "...": "..."
  }
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 3: "TITLE": "RdvMedecins - NestJS / React port", – nur der Untertitel ändert sich: „[RdvMedecins]“ bleibt in beiden Sprachen unverändert; es ist der Eigenname der Anwendung.

Beide Dateien müssen strukturell identisch bleiben (gleiche Schlüssel in beiden): So ist sichergestellt, dass ein Schlüssel in beiden Sprachen existiert. Was NICHT übersetzt wird, bleibt gegenüber der [Angular]-Variante dieses Kurses unverändert: Fehlermeldungen, die der Server [NestJS] zurückgibt, bleiben unabhängig von der auf Client-Seite gewählten Sprache englisch, und die Namen der Ärzte und Patienten stammen direkt aus der Datenbank.

6.8. Die Schicht core/interceptors

Image

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

[React] ist lediglich eine Bibliothek für Benutzeroberflächen und kennt daher kein integriertes Konzept für HTTP-Interceptoren, wie es mit [HttpClient]/withInterceptors ([...]) auf der Seite von [Angular] existiert. Diese Datei setzt dasselbe Konzept als Hook um, der [fetch] kapselt: Das ist das moderne Äquivalent der $http-Interceptoren aus AngularJS 1.x, die bereits im ursprünglichen Dokument behandelt wurden (Kapitel „Beispiel 6“).

import { useAuth } from '../context/auth.context';

export function useAuthFetch() {
  const auth = useAuth();

  return async function authFetch(input: RequestInfo | URL, init: RequestInit = {}): Promise<Response> {
    const headers = new Headers(init.headers);
    if (auth.accessToken) {
      headers.set('Authorization', `Bearer ${auth.accessToken}`);
    }
    const response = await fetch(input, { ...init, headers });
    if (response.status === 401) {
      auth.logOut();
    }
    return response;
  };
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 3: export function useAuthFetch() { – anders als [authInterceptor] auf der Seite von [Angular] (eine Funktion, die einmalig in [app.config.ts] registriert und dann automatisch auf jeden Aufruf von [HttpClient] angewendet wird) ist [useAuthFetch()] ein Hook, den jeder Aufrufer (hier useAppointmentService(), siehe unten) explizit aufrufen und anstelle von fetch() verwenden muss – ein Unterschied im Mechanismus der beiden Bibliotheken, nicht im endgültigen Verhalten;
  • Zeilen 6–10: if (auth.accessToken) { headers.set('Authorization', …); } – das direkte Äquivalent zu [request.clone({ setHeaders: { Authorization: … } })] auf der Seite von [Angular]. Anders als eine [HttpClient]-Anfrage (die unveränderlich ist) sind die Optionen von [fetch] einfach ein JavaScript-Objekt: Es ist nicht nötig, davon eine „geklonte“ Kopie anzulegen; man muss lediglich das Objekt [headers] vor dem Aufruf aufbauen;
  • Zeilen 12–14: if (response.status === 401) { auth.logOut(); } – gleiches Prinzip wie auf der Seite von [Angular] (catchError + HttpErrorResponse.status === 401): Ein 401 während einer Sitzung bedeutet, dass das Token nicht mehr gültig ist, daher wird der Client ordnungsgemäß abgemeldet; hier [fetch] weist sein Promise bei einem HTTP-Status nicht als Fehler zurück (anders als ein Observable von [HttpClient]) – deshalb prüft dieser Test direkt [response.status], ohne try/catch-Block;
  • Zeile 15: return response; – die (möglicherweise 401-)Antwort wird dennoch unverändert an den Aufrufer zurückgegeben, der für ihre Behandlung verantwortlich bleibt (siehe useAppointmentService(), extract<T>(), weiter unten) – der Interceptor darf den Fehler nicht vor dem aufrufenden Code verbergen.

Wir könnten [Authorization: Bearer ...] manuell zu jeder der Methoden in [useAppointmentService()] hinzufügen. Ein gemeinsamer Hook vermeidet diese Wiederholung und bietet denselben Vorteil wie ein Interceptor in [Angular]: Die Frage „Wie authentifizieren wir eine Anfrage?“ wird an einer einzigen Stelle beantwortet.

6.9. Die Schicht core/services

Image

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

Portierung von [AppointmentService]: der Teil der Anwendung (der EINZIGE, zusammen mit [core/context/auth.context.tsx] für die Anmeldung selbst), der per HTTP mit dem [NestJS]-Server kommuniziert. Dies ist das direkte Äquivalent des Services [dao], der im Kapitel „Beispiel 6: die HTTP-Services“ des ursprünglichen Dokuments vorgestellt wurde (das den AngularJS-Service $http verwendete).

import { useCallback } from 'react';
import { useAuthFetch } from '../interceptors/auth.interceptor';
import { useSettings } from '../context/settings.context';
import type { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';

async function extract<T>(httpResponse: Response): Promise<T> {
  const envelope = (await httpResponse.json()) as ServerResponse<T>;
  if (envelope.status !== 0) {
    throw new Error(`The server answered with the error status ${envelope.status}`);
  }
  return envelope.data as T;
}

export function useAppointmentService() {
  const authFetch = useAuthFetch();
  const { apiBaseUrl } = useSettings();

  const getAllDoctors = useCallback(async (): Promise<Doctor[]> => {
    const httpResponse = await authFetch(`${apiBaseUrl}/getAllDoctors`);
    return extract<Doctor[]>(httpResponse);
  }, [authFetch, apiBaseUrl]);

  const getAllClients = useCallback(async (): Promise<Client[]> => {
    const httpResponse = await authFetch(`${apiBaseUrl}/getAllClients`);
    return extract<Client[]>(httpResponse);
  }, [authFetch, apiBaseUrl]);

  const getDoctorScheduleOfDay = useCallback(
    async (doctorId: number, day: string): Promise<DoctorDaySchedule> => {
      const httpResponse = await authFetch(
        `${apiBaseUrl}/getDoctorScheduleOfDay/${doctorId}/${day}`,
      );
      return extract<DoctorDaySchedule>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  const addAppointment = useCallback(
    async (day: string, clientId: number, slotId: number): Promise<AppointmentJson> => {
      const httpResponse = await authFetch(`${apiBaseUrl}/addAppointment`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ day, clientId, slotId }),
      });
      return extract<AppointmentJson>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  const deleteAppointment = useCallback(
    async (appointmentId: number): Promise<void> => {
      const httpResponse = await authFetch(`${apiBaseUrl}/deleteAppointment`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ appointmentId }),
      });
      await extract<null>(httpResponse);
    },
    [authFetch, apiBaseUrl],
  );

  return { getAllDoctors, getAllClients, getDoctorScheduleOfDay, addAppointment, deleteAppointment };
}

Kommentieren wir diesen Code:

  • Zeile 6: async function extract<T>(httpResponse: Response): Promise<T> { – statt in jeder der öffentlichen Funktionen die Prüfung „wenn status !== 0, liegt ein Fehler vor“ zu wiederholen, zentralisieren wir sie hier ein einziges Mal – genau die Rolle von [AppointmentService.extract()] auf der Seite von [Angular], jedoch außerhalb des Hooks deklariert (eine gewöhnliche Funktion, die daher nicht bei jedem Rendern neu erstellt werden muss);
  • Zeile 14: export function useAppointmentService() { – ein benutzerdefinierter Hook, der genau wie [inject(AppointmentService)] auf der Seite von [Angular] gelesen und verwendet wird: Er wird einmal am Anfang einer Komponente aufgerufen, danach werden die von ihm zurückgegebenen Funktionen verwendet;
  • Zeilen 18–21: const getAllDoctors = useCallback(async () => { … }, [authFetch, apiBaseUrl]); – [useCallback]() hält diese Funktion zwischen den Renderings im Cache, solange sich [authFetch] und [[apiBaseUrl]] nicht ändern: Diese Optimierung ist hier notwendig, weil dieser Hook bei jedem Rendern der Komponente aufgerufen wird, die ihn verwendet (App.tsx) – ohne sie würde bei jedem Rendern eine neue Funktion [getAllDoctors] erstellt, was bestimmte Effekte unnötigerweise erneut auslösen würde (useEffect(…, [api]), siehe App.tsx weiter unten); dieses technische Detail hat auf der Seite von [Angular] keine Entsprechung, wo [AppointmentService] nur ein einziges Mal für die gesamte Anwendung existiert (providedIn: 'root');
  • jede Funktion entspricht genau einer der elf Routen des [NestJS]-Controllers (Kapitel 3) – tatsächlich tauchen auf beiden Seiten dieselben Namen auf (getAllDoctors, addAppointment, deleteAppointment …), was den Vergleich zwischen Server- und Client-Seite erleichtert, genau wie bei [Angular].

Anders als [AuthService.logIn()] (vorheriges Kapitel) muss keine der Methoden dieses Hooks nach dem Aufruf etwas speichern: Die aufrufende Komponente (App.tsx) entscheidet, was mit dem Ergebnis geschieht (setDoctors(...), setSchedule(...) …) – dieselbe Aufgabentrennung wie auf der Seite von [Angular], wo [AppointmentService] nichts über den auf dem Bildschirm angezeigten Zustand weiß.

6.10. Die Schicht features: die vier Komponenten

Image

6.10.1. src/app/features/login/Login.tsx

Portierung von [login.component.ts/.html]: der Anmeldebildschirm, Äquivalent zur View [login.html] des ursprünglichen AngularJS-1.x-Clients.

import { useState, type FormEvent } from 'react';
import { useTranslation } from 'react-i18next';
import { useAuth } from '../../core/context/auth.context';
import './login.css';

export function Login() {
  const { t } = useTranslation();
  const auth = useAuth();

  const [login, setLogin] = useState('');
  const [password, setPassword] = useState('');
  const [submitting, setSubmitting] = useState(false);
  const [error, setError] = useState<string | null>(null);

  async function onSubmit(event?: FormEvent): Promise<void> {
    event?.preventDefault();
    if (login.trim() === '' || password === '') {
      return;
    }
    setError(null);
    setSubmitting(true);
    try {
      await auth.logIn(login, password);
      setSubmitting(false);
    } catch {
      setSubmitting(false);
      setError('LOGIN.ERROR');
    }
  }

  return (
    <div className="row justify-content-center">
      <div className="col-sm-8 col-md-6 col-lg-4">
        <form className="card p-4" onSubmit={onSubmit}>
          <h5 className="card-title mb-3">{t('LOGIN.TITLE')}</h5>
          {error && (
            <div className="alert alert-danger py-2" role="alert">
              {t(error)}
            </div>
          )}
          <div className="mb-3">
            <label className="form-label" htmlFor="input-login">
              {t('LOGIN.LOGIN_LABEL')}
            </label>
            <input id="input-login" type="text" className="form-control"
              value={login} onChange={(e) => setLogin(e.target.value)} />
          </div>
          <div className="mb-3">
            <label className="form-label" htmlFor="input-password">
              {t('LOGIN.PASSWORD_LABEL')}
            </label>
            <input id="input-password" type="password" className="form-control"
              value={password} onChange={(e) => setPassword(e.target.value)} />
          </div>
          <button type="submit" className="btn btn-primary w-100" disabled={submitting}>
            {submitting ? t('LOGIN.SUBMITTING') : t('LOGIN.SUBMIT')}
          </button>
        </form>
      </div>
    </div>
  );
}

Kommentieren wir diesen Code:

  • Zeile 6: export function Login() { – eine eigenständige (Standalone-)Komponente von [Angular] deklariert in ihrem Dekorator [@Component] die Pipes, die sie verwendet (imports: [TranslatePipe]); eine [React]-Komponente hat nichts Vergleichbares zu deklarieren: [useTranslation()]] (Zeile 7) wird einfach importiert und wie jede andere Funktion aufgerufen;
  • Zeilen 10–13: const [login, setLogin] = useState(''); … – ein Zustand, der rein lokal zum Formular gehört (was der Benutzer gerade eintippt), Äquivalent zu [signal()] lokalen Variablen der [Angular]-Komponente;
  • Zeilen 15–16: async function onSubmit(event?: FormEvent): Promise<void> { event?.preventDefault(); – ein bewusster Unterschied zur [Angular]-Variante dieses Kurses: Statt jedes Feld einzeln abzuhören (keyup.enter), verwendet diese Komponente ein echtes <form>-Element (Zeile 34) und dessen natives [onSubmit]-Ereignis – sowohl die Eingabetaste als auch ein Klick auf die Schaltfläche „Log in“ (type="submit") lösen dann [onSubmit()] aus, ohne zusätzlichen Code; [event?.preventDefault()] verhindert das Standardverhalten des Browsers (das Neuladen der Seite), das dem eigentlichen Prinzip einer Single-Page-Anwendung widerspräche;
  • Zeilen 23–24: await auth.logIn(login, password); setSubmitting(false); – hier ist keine weitere Verarbeitung nötig: [AuthContext] hat die Sitzung bereits gespeichert (Zustand + localStorage) – es ist App.tsx, das useAuth().isLoggedIn aufruft und daraufhin die Anzeige von <Login /> beendet;
  • Zeilen 24–27: catch { … setError('LOGIN.ERROR'); } – ein ungültiges Paar aus Benutzername und Passwort lässt [logIn()] mit einer JavaScript-Ausnahme fehlschlagen (ausgelöst von [auth.context.tsx], siehe oben): „LOGIN.ERROR“ wird dem Benutzer angezeigt, ohne zwischen einem nicht existierenden Benutzernamen und einem falschen Passwort zu unterscheiden – exakt derselbe Ansatz wie in [Angular]. Einen Übersetzungsschlüssel statt eines bereits aufgelösten Textes zu speichern, hat denselben Vorteil wie in [Angular]: Wechselt der Benutzer die Sprache, während diese Meldung angezeigt wird, übersetzt sie sich automatisch (t(error), Zeile 38, bei jedem Rendern neu ausgewertet).

Diese Komponente vereint in EINER einzigen .tsx-Datei, was [Angular] auf zwei Dateien aufteilt (login.component.ts für die Logik, login.component.html für das Template): Das von der Funktion Login() zurückgegebene [JSX] IST das Template, kombiniert mit dem TypeScript-Code, der es steuert. Daher gibt es keine separate .html-Datei zu kommentieren, anders als im entsprechenden Kapitel der [Angular]-Variante dieses Kurses.

6.10.2. src/app/features/doctor-day-picker/DoctorDayPicker.tsx

Portierung von [doctor-day-picker.component.ts/.html]: die Komponente, mit der Sie einen Arzt und einen Tag auswählen und dann die Anzeige seines Terminkalenders anfordern können. Konzeptionell gleichwertig mit den Beispielen 7 bis 10 des ursprünglichen AngularJS-1.x-Clients.

import { useState, type ChangeEvent } from 'react';
import { useTranslation } from 'react-i18next';
import type { Doctor } from '../../core/models/appointment.models';
import './doctor-day-picker.css';

interface DoctorDayPickerProps {
  doctors: Doctor[];
  onSearch: (criteria: { doctorId: number; day: string }) => void;
}

export function DoctorDayPicker({ doctors, onSearch }: DoctorDayPickerProps) {
  const { t } = useTranslation();
  const [selectedDoctorId, setSelectedDoctorId] = useState<number | null>(null);
  const [selectedDay, setSelectedDay] = useState<string>(
    new Date().toISOString().slice(0, 10),
  );

  function onDoctorChange(event: ChangeEvent<HTMLSelectElement>): void {
    const value = event.target.value;
    setSelectedDoctorId(value === '' ? null : Number(value));
  }

  function onSearchClick(): void {
    if (selectedDoctorId === null) {
      return;
    }
    onSearch({ doctorId: selectedDoctorId, day: selectedDay });
  }

  return (
    <div className="card p-3 mb-3">
      <div className="row g-2 align-items-end">
        <div className="col-sm-5">
          <label className="form-label" htmlFor="select-doctor">
            {t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')}
          </label>
          <select id="select-doctor" className="form-select" onChange={onDoctorChange}>
            <option value="">{t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')}</option>
            {doctors.map((doctor) => (
              <option key={doctor.id} value={doctor.id}>
                {doctor.title} {doctor.firstName} {doctor.lastName}
              </option>
            ))}
          </select>
        </div>
        <div className="col-sm-4">
          <input id="input-day" type="date" className="form-control"
            value={selectedDay} onChange={(e) => setSelectedDay(e.target.value)} />
        </div>
        <div className="col-sm-3">
          <button type="button" className="btn btn-primary w-100"
            disabled={selectedDoctorId === null} onClick={onSearchClick}>
            {t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE')}
          </button>
        </div>
      </div>
    </div>
  );
}

Kommentieren wir diesen Code:

  • Zeile 11: export function DoctorDayPicker({ doctors, onSearch }: DoctorDayPickerProps) { – ein [input.required<Doctor[]>()] [Angular] wird einfach zu einem Feld des `props`-Objekts (`doctors`); ein `output<...>()` wird zu einer Prop, die eine Callback-Funktion enthält, die vom übergeordneten `[(onSearch)]` bereitgestellt wird – `[App.tsx]` ruft sie genau so auf, wie es das Ereignis `search` im `[Angular]` -Template abonniert hatte;
  • Zeilen 39–43: {doctors.map((doctor) => ( <option key={doctor.id} …>…</option> ))} – .map(...) mit [key={doctor.id}] ist das [React]-Äquivalent zu [@for (doctor of doctors(); track doctor.id)] auf der Seite von [Angular]: In beiden Fällen legt ein stabiler Bezeichner fest, wie ein bereits angezeigter Arzt wiedererkannt wird, wenn er neu gezeichnet wird;
  • Zeile 37: onChange={onDoctorChange} – anders als beim Feld „login“ von [Login.tsx] (das [onChange] bei jedem Tastendruck verwendet) meldet ein <select> nur dann etwas, wenn sich die Auswahl tatsächlich ändert – dasselbe HTML-Ereignis [change] , das auf der Seite von [(change)="onDoctorChange($event)] bereits [Angular] verwendet wurde.

6.10.3. src/app/features/schedule/Schedule.tsx

Portierung von [schedule.component.ts/.html]: zeigt den Terminkalender eines Arztes für einen bestimmten Tag an. Entspricht den Beispielen 8 und 9 des ursprünglichen AngularJS-1.x-Clients. Seit der Einführung der Authentifizierung akzeptiert diese Komponente außerdem [canEdit]: Ist der Wert false (Rolle USER), verschwinden die Schaltflächen „Book“/„Cancel“ – der Terminkalender bleibt einsehbar, jedoch im schreibgeschützten Modus.

import { useTranslation } from 'react-i18next';
import type { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';
import './schedule.css';

interface ScheduleProps {
  schedule: DoctorDaySchedule | null;
  canEdit: boolean;
  onBook: (slot: SlotJson) => void;
  onCancel: (appointment: AppointmentJson) => void;
}

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

export function Schedule({ schedule, canEdit, onBook, onCancel }: ScheduleProps) {
  const { t } = useTranslation();

  function onSlotClick(scheduleSlot: ScheduleSlot): void {
    if (!canEdit) {
      return;
    }
    if (scheduleSlot.appointment === null) {
      onBook(scheduleSlot.slot);
    } else {
      onCancel(scheduleSlot.appointment);
    }
  }

  if (schedule === null) {
    return <p className="text-muted">{t('SCHEDULE.EMPTY_STATE')}</p>;
  }

  return (
    <div className="card p-3">
      <h5>
        {t('SCHEDULE.TITLE_PREFIX')} {schedule.day} - {schedule.doctor.title} {schedule.doctor.firstName} {schedule.doctor.lastName}
      </h5>
      <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>
          {schedule.slots.map((scheduleSlot) => (
            <tr key={scheduleSlot.slot.id}
              className={scheduleSlot.appointment === null ? 'free-slot' : undefined}>
              <td>
                {formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute)} -{' '}
                {formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute)}
              </td>
              <td>
                {scheduleSlot.appointment === null ? (
                  <span className="badge text-bg-success">{t('SCHEDULE.FREE')}</span>
                ) : (
                  <span className="badge text-bg-secondary">
                    {scheduleSlot.appointment.client?.title} {scheduleSlot.appointment.client?.firstName} {scheduleSlot.appointment.client?.lastName}
                  </span>
                )}
              </td>
              <td>
                {canEdit && (
                  <button type="button" className={'btn btn-sm ' +
                    (scheduleSlot.appointment === null ? 'btn-outline-success' : 'btn-outline-danger')}
                    onClick={() => onSlotClick(scheduleSlot)}>
                    {scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')}
                  </button>
                )}
              </td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
}

Kommentieren wir diesen Code:

  • Zeilen 30–32: if (schedule === null) { return <p …>{t('SCHEDULE.EMPTY_STATE')}</p>; } – ein früher Rücksprung (Early Return) ersetzt [@if (schedule(); as currentSchedule) { … } @else { … }] auf der Seite von [Angular]: Eine Komponentenfunktion von [React] kann an jeder Stelle ihres Rumpfes beliebiges [JSX] zurückgeben, auch vor dem Ende – hier bricht die Funktion, solange keine Suche durchgeführt wurde (oder der Terminkalender leer ist), nach der Anzeige der Meldung über den leeren Zustand ab, ohne das Array überhaupt aufzubauen;
  • Zeile 7: canEdit: boolean; – eine durch die Authentifizierung eingeführte Neuerung, ähnlich wie auf der Seite von [Angular]: [App.tsx] übergibt ihr [auth.isAdmin] (siehe unten). Ist der Wert false (Rolle USER), existieren die Schaltflächen „Book“/„Cancel“ nicht einmal im DOM (siehe Zeile 61, [{canEdit && (…)}]) – sie sind nicht bloß ausgegraut oder deaktiviert, sondern vollständig abwesend;
  • Zeilen 52–58: {scheduleSlot.appointment === null ? ( <span …>Free</span> ) : ( <span …>{patient name}</span> )} – der ternäre Operator ersetzt [@if (…) { … } @else { … }] auf der Seite von [Angular]: ein grünes [Bootstrap]-Badge („Free“) oder ein graues (Name des Patienten), je nach Status des Zeitfensters;
  • Zeile 61: {canEdit && (…)} – der Operator && zeigt seinen zweiten Operanden nur an, wenn der erste wahr ist (andernfalls überhaupt nichts) – die kürzeste Form des bedingten Renderns in [JSX], hier anstelle des ternären Operators verwendet, weil andernfalls nichts anzuzeigen ist;
  • Zeile 65: {scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT')} – wie auf der Seite von [Angular] (wo eine Pipe in jedem Template-Ausdruck verwendet werden kann) ist t(...) eine gewöhnliche JavaScript-Funktion: Sie kann ohne besondere Syntax direkt in einem ternären Operator verwendet werden.

Diese Komponente führt selbst keine HTTP-Aufrufe durch: Sie zeigt die über Props empfangenen Daten an und teilt ihrer übergeordneten Komponente (App.tsx) die Absichten des Benutzers über [onBook/onCancel] mit – exakt dieselbe Aufgabentrennung wie auf der Seite von [Angular] (book/cancel, über output()).

6.10.4. src/app/features/booking-dialog/BookingDialog.tsx

Portierung von [booking-dialog.component.ts/.html]: das (modale) Fenster, in dem Sie einen Patienten auswählen können, um einen freien Zeitslot zu buchen. Entspricht Beispiel 9 des ursprünglichen AngularJS-1.x-Clients.

import { useState, type ChangeEvent } from 'react';
import { useTranslation } from 'react-i18next';
import type { Client, SlotJson } from '../../core/models/appointment.models';
import './booking-dialog.css';

interface BookingDialogProps {
  open: boolean;
  slot: SlotJson | null;
  clients: Client[];
  onConfirm: (choice: { clientId: number }) => void;
  onClose: () => void;
}

export function BookingDialog({ open, slot, clients, onConfirm, onClose }: BookingDialogProps) {
  const { t } = useTranslation();
  const [selectedClientId, setSelectedClientId] = useState<number | null>(null);

  if (!open) {
    return null;
  }

  function onClientChange(event: ChangeEvent<HTMLSelectElement>): void {
    const value = event.target.value;
    setSelectedClientId(value === '' ? null : Number(value));
  }

  function onConfirmClick(): void {
    if (selectedClientId === null) {
      return;
    }
    onConfirm({ clientId: selectedClientId });
    setSelectedClientId(null);
  }

  return (
    <>
      <div className="modal-backdrop fade show"></div>
      <div className="modal fade show d-block" tabIndex={-1} role="dialog" aria-modal="true">
        <div className="modal-dialog modal-dialog-centered">
          <div className="modal-content">
            <div className="modal-header">
              <h5 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">
              {slot && (
                <p>
                  {t('BOOKING_DIALOG.SLOT_FROM')} {slot.startHour}:{slot.startMinute.toString().padStart(2, '0')}{' '}
                  {t('BOOKING_DIALOG.SLOT_TO')} {slot.endHour}:{slot.endMinute.toString().padStart(2, '0')}
                </p>
              )}
              <select id="select-client" className="form-select" onChange={onClientChange}>
                <option value="">{t('BOOKING_DIALOG.CHOOSE_PATIENT')}</option>
                {clients.map((client) => (
                  <option key={client.id} value={client.id}>
                    {client.title} {client.firstName} {client.lastName}
                  </option>
                ))}
              </select>
            </div>
            <div className="modal-footer">
              <button type="button" className="btn btn-secondary" onClick={onClose}>
                {t('BOOKING_DIALOG.CANCEL')}
              </button>
              <button type="button" className="btn btn-primary"
                disabled={selectedClientId === null} onClick={onConfirmClick}>
                {t('BOOKING_DIALOG.CONFIRM')}
              </button>
            </div>
          </div>
        </div>
      </div>
    </>
  );
}

Kommentieren wir diesen Code:

  • Zeilen 18–20: if (!open) { return null; } – eine [React]-Komponente kann null zurückgeben, um gar nichts anzuzeigen: Das ist das exakte Äquivalent zu [@if (open()) { … }] auf der Seite von [Angular] (solange `open` false ist, wird nicht einmal etwas in das DOM geladen) und zu [ngIf/ngShow] in AngularJS 1.x;
  • Zeile 37: <div className="modal-backdrop fade show"></div> – der halbtransparente Hintergrund, der den Rest der Seite abdunkelt – hier fest codiert, während [Bootstrap] ihn beim Anzeigen des Modals üblicherweise selbst per JavaScript einfügt;
  • Zeile 38: <div className="modal fade show d-block" …> – d-block übernimmt die Rolle, die normalerweise das JavaScript von [Bootstrap] erfüllt ([display:block] beim Öffnen hinzufügen) – hier ist es unmittelbar das bedingte Rendern aus Zeile 18 ([if (!open) return null;]), das diese Rolle spielt;
  • Zeile 44: aria-label={t('BOOKING_DIALOG.CLOSE_ARIA')} – anders als [attr.aria-label="'BOOKING_DIALOG.CLOSE_ARIA' | translate"] auf der Seite von [Angular] (ein Attribut-Binding, das sich von der Interpolation {{ }} unterscheidet) macht [JSX] keinen Unterschied zwischen einem HTML-Attribut und dem Inhalt eines Elements: {expression} wird an beiden Stellen identisch verwendet.

Wie auf der Seite von [Angular] verwendet diese Komponente die ECHTEN Klassen eines Modals, doch ihre Sichtbarkeit wird von [React] gesteuert (ein bedingtes Rendern auf Basis der Eigenschaft [open]) und nicht vom JavaScript von [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)]) – um zu verhindern, dass [Bootstrap] und [React] jeweils unabhängig voneinander dieselbe Information verwalten (ist das Modal geöffnet?), eine häufige Quelle subtiler Fehler. Das ursprüngliche Dokument (2014) verwendete eine Komponente aus der Bibliothek angular-ui-bootstrap (ein „schlüsselfertiges“ Modal für AngularJS 1.x), die bereits nach demselben Prinzip entworfen war.

6.11. Die Wurzelkomponente App: Orchestrator und Wächter der Authentifizierung

Image

Diese Komponente erfüllt die Rolle des „Hauptcontrollers“ der ursprünglichen AngularJS-1.x-Anwendung und der Komponente App auf der Seite von [Angular]: Sie hält den globalen Zustand der Anwendung und reagiert auf Ereignisse der Komponenten aus features/, um zum richtigen Zeitpunkt [useAppointmentService()] aufzurufen. Seit der Einführung der Authentifizierung hat sie eine zweite Rolle übernommen: die eines „Torwächters“ auf der Präsentationsschicht, der entscheidet, ob der Anmeldebildschirm oder der Rest der Anwendung angezeigt wird. Eine [React]-Komponente vereint in einer einzigen .tsx-Datei, was [Angular] auf drei Dateien aufteilt ([app.ts, app.html, app.css]): Das von App() zurückgegebene [JSX] IST das Template ([App.css] wird weiter unten ausschließlich wegen seines Seiteneffekts importiert).

6.11.1. src/app/App.tsx

import { useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';
import { useAuth } from './core/context/auth.context';
import { useSettings } from './core/context/settings.context';
import { useLanguage } from './core/context/language.context';
import { useAppointmentService } from './core/services/appointment.service';
import type { DoctorDaySchedule, Client, SlotJson, Doctor, AppointmentJson } from './core/models/appointment.models';
import { DoctorDayPicker } from './features/doctor-day-picker/DoctorDayPicker';
import { Schedule } from './features/schedule/Schedule';
import { BookingDialog } from './features/booking-dialog/BookingDialog';
import { Login } from './features/login/Login';
import './App.css';

export function App() {
  const { t } = useTranslation();
  const auth = useAuth();
  const settings = useSettings();
  const language = useLanguage();
  const api = useAppointmentService();

  const [doctors, setDoctors] = useState<Doctor[]>([]);
  const [clients, setClients] = useState<Client[]>([]);
  const [schedule, setSchedule] = useState<DoctorDaySchedule | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [slotBeingBooked, setSlotBeingBooked] = useState<SlotJson | null>(null);

  const lastDoctorId = useRef<number | null>(null);
  const lastDay = useRef<string | null>(null);

  useEffect(() => {
    if (auth.isLoggedIn) {
      loadInitialLists();
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [auth.isLoggedIn]);

  function loadInitialLists(): void {
    api.getAllDoctors().then(setDoctors)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
    api.getAllClients().then(setClients)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function onLogout(): void {
    auth.logOut();
    setDoctors([]); setClients([]); setSchedule(null);
    setError(null); setSlotBeingBooked(null);
    lastDoctorId.current = null; lastDay.current = null;
  }

  function onSearchSchedule(criteria: { doctorId: number; day: string }): void {
    setError(null);
    lastDoctorId.current = criteria.doctorId;
    lastDay.current = criteria.day;
    loadSchedule();
  }

  function onBookingRequest(slot: SlotJson): void {
    setSlotBeingBooked(slot);
  }

  function onConfirmBooking(choice: { clientId: number }): void {
    if (slotBeingBooked === null || lastDay.current === null) {
      return;
    }
    api.addAppointment(lastDay.current, choice.clientId, slotBeingBooked.id)
      .then(() => { setSlotBeingBooked(null); loadSchedule(); })
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function onCancelAppointment(appointment: AppointmentJson): void {
    api.deleteAppointment(appointment.id).then(() => loadSchedule())
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  function loadSchedule(): void {
    if (lastDoctorId.current === null || lastDay.current === null) {
      return;
    }
    api.getDoctorScheduleOfDay(lastDoctorId.current, lastDay.current).then(setSchedule)
      .catch((err: unknown) => setError(String((err as Error).message ?? err)));
  }

  return (
    <div className="container py-4">
      <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>
        <div className="d-flex align-items-center gap-2">
          <div className="btn-group btn-group-sm" role="group" aria-label="FR / EN">
            <button type="button" onClick={() => language.changeLanguage('fr')}
              className={'btn ' + (language.currentLanguage === 'fr' ? 'btn-light' : 'btn-outline-light')}>FR</button>
            <button type="button" onClick={() => language.changeLanguage('en')}
              className={'btn ' + (language.currentLanguage === 'en' ? 'btn-light' : 'btn-outline-light')}>EN</button>
          </div>
          {auth.isLoggedIn && (
            <>
              <span className="badge text-bg-light text-primary">{auth.role}</span>
              <span className="text-white">{auth.name}</span>
              <button type="button" className="btn btn-sm btn-outline-light" onClick={onLogout}>
                {t('APP.LOGOUT')}
              </button>
            </>
          )}
        </div>
      </nav>

      <div className="row g-2 align-items-center mb-4">
        <div className="col-auto">
          <label className="form-label mb-0" htmlFor="input-server-url">{t('APP.SERVER_URL_LABEL')}</label>
        </div>
        <div className="col-sm-4">
          <input id="input-server-url" type="text" className="form-control form-control-sm"
            defaultValue={settings.apiBaseUrl} onChange={(e) => settings.setApiBaseUrl(e.target.value)} />
        </div>
      </div>

      {error && <div className="alert alert-danger" role="alert">{error}</div>}

      {!auth.isLoggedIn ? (
        <Login />
      ) : (
        <>
          <DoctorDayPicker doctors={doctors} onSearch={onSearchSchedule} />
          <Schedule schedule={schedule} canEdit={auth.isAdmin}
            onBook={onBookingRequest} onCancel={onCancelAppointment} />
          <BookingDialog open={slotBeingBooked !== null} slot={slotBeingBooked}
            clients={clients} onConfirm={onConfirmBooking} onClose={() => setSlotBeingBooked(null)} />
        </>
      )}
    </div>
  );
}

Kommentieren wir diesen Code:

  • Zeilen 27–28: const lastDoctorId = useRef<number | null>(null); const lastDay = useRef<string | null>(null); – wir speichern die letzte Suche (Arzt + Tag), um den Terminkalender nach einer Buchung oder Stornierung aktualisieren zu können. Ein [useRef]() und kein [useState](): Diese beiden Werte werden nie direkt zur Anzeige verwendet (anders als „schedule“ oder „error“), sodass die Komponente bei einer Änderung nicht neu gezeichnet werden muss – exakt dieselbe Überlegung, aufgrund derer auf der Seite von [Angular] [lastDoctorId/lastDay] als einfache private Felder statt als Signale gehalten wurden; Das Ändern eines [useRef]() (.current = …) zeichnet die Komponente nicht neu, anders als ein [setXxx()] von [useState]();
  • Zeilen 30–35: useEffect(() => { if (auth.isLoggedIn) { loadInitialLists(); } }, [auth.isLoggedIn]); – führt seinen Rumpf jedes Mal erneut aus, wenn sich [auth.isLoggedIn] ändert – das direkte Äquivalent zu [effect(() => { if (this.auth.isLoggedIn()) { … } })] auf der Seite von [Angular]. Er läuft außerdem einmal, wenn die Komponente eingehängt wird: War bereits eine Sitzung in [localStorage] gespeichert (Neuladen der Seite), werden die Listen sofort beim Start geladen, ohne auf eine Anmeldung zu warten;
  • Zeilen 89–94: <div className="btn-group btn-group-sm" …> …FR…EN… </div> – die Sprachauswahl ist sichtbar (auch auf dem Anmeldebildschirm); das Rollen-Badge, der Name und die Abmelden-Schaltfläche werden dagegen nur angezeigt, wenn [auth.isLoggedIn] (Zeilen 95–103, [{auth.isLoggedIn && (…)})] – exakt dieselbe Logik wie auf den Seiten von [Angular] and [(@if (auth.isLoggedIn()) { … })] ;
  • Zeilen 119–130: {!auth.isLoggedIn ? ( <Login /> ): ( <>…</> )} – solange [useAuth().isLoggedIn] gleich false ist, zeigt diese Komponente nur <Login /> an; da nun alle Server-Routen durch [JwtAuthGuard] geschützt sind (Kapitel 3), wäre es ohnehin sinnlos (und würde 401-Fehler verursachen), vor der Anmeldung Ärzte/Kunden/Terminkalender zu laden – exakt dieselbe Überlegung wie bei [Angular];
  • Zeilen 123–127: <DoctorDayPicker doctors={doctors} onSearch={onSearchSchedule} /> … – die drei „Fachlogik“-Komponenten aus features/ werden hier zusammengesetzt und erhalten jeweils ihre Props (Daten + Callback-Funktionen) – das exakte Äquivalent zum Template [app.html] auf der Seite von [Angular], wo dieselben drei Komponenten mit [doctors]="doctors()" erschienen ([search)="onSearchSchedule($event)"] …).

Zustand ([useState/useRef]), Effekt ([useEffect]) und Ereignisbehandler (die onXxx-Funktionen): Das sind exakt die vier Bausteine, die im vorherigen Kapitel bereits vorgestellt wurden, hier angewendet auf die gesamte Wurzelkomponente – in dieser Datei wurde nichts Neues eingeführt; sie wurde lediglich zusammengesetzt.

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

Die folgenden Screenshots wurden mit exakt derselben Abfolge von Aktionen wie bei der [Angular]-Variante dieses Kurses erstellt, hier mit diesem [React]-Client: Die Einstellung für die URL des Servers blieb auf ihrem Standardwert (http://localhost:8080), mit den Demo-Konten admin/admin und user/user.

6.12.1. 1. Anmeldebildschirm

Beim ersten Laden der Seite ist [useAuth().isLoggedIn] gleich false (keine Sitzung in localStorage): Es wird nur <Login /> angezeigt.

Image

Anmeldebildschirm

Ein Versuch mit einer ungültigen Kombination aus Benutzername und Passwort zeigt die von [Login.tsx] gespeicherte Fehlermeldung an:

Image

Anmeldefehler

Die stets sichtbare Auswahl FR/EN übersetzt auch diesen Bildschirm ins Französische (und die gespeicherte Fehlermeldung, die ohne zusätzlichen Code neu übersetzt wird; siehe [Login.tsx] oben):

Image

Anmeldebildschirm auf Französisch

6.12.2. 2. Anmeldung als Administrator (Rolle ADMIN, voller Zugriff)

Nach der Anmeldung mit admin/admin beendet [App.tsx] die Anzeige von <Login /> und lädt Ärzte/Kunden ([loadInitialLists()], ausgelöst durch [useEffect(…, [auth.isLoggedIn])] in Zeile 30):

Image

Startseite nach der Anmeldung als ADMIN

Image

Startseite nach der Anmeldung als ADMIN, auf Französisch

Nach der Auswahl eines Arztes und eines Datums in <DoctorDayPicker /> wird der Terminkalender mit den Schaltflächen „Book“/„Cancel“ angezeigt (canEdit ist für die Rolle ADMIN auf true gesetzt):

Image

Terminkalender, ADMIN-Ansicht (Schaltflächen Book/Cancel sichtbar)

Ein Klick auf „Book“ öffnet <BookingDialog /> ([open] wechselt auf true; siehe [onBookingRequest] in [App.tsx]):

Image

Buchungsfenster (Bootstrap-Modal)

Nach der Bestätigung ([onConfirmBooking] ruft [api.addAppointment(...)] auf, dann aktualisiert [loadSchedule()] die Anzeige), erscheint der Zeitslot als gebucht:

Image

Terminkalender nach der Buchung

Ein Klick auf „Cancel“ ([onCancelAppointment] ruft [api.deleteAppointment(...)] auf) macht den Zeitslot wieder verfügbar:

Image

Terminkalender nach der Stornierung

6.12.3. 3. Anmeldung als Benutzer (Rolle USER, schreibgeschützt)

Nach dem Abmelden (onLogout) zeigt die Anmeldung mit dem Konto user/user ein anderes Badge an: „USER“:

Image

Startseite nach der Anmeldung als USER

Der Terminkalender bleibt einsehbar, aber es erscheinen keine Schaltflächen „Book“/„Cancel“: Die Aktionsspalte ist für jeden Zeitslot leer (siehe [Schedule.tsx, {canEdit && (…)}]). Eine direkte Anfrage an den Server (zum Beispiel mit Postman unter Angabe des Tokens des Benutzers) würde weiterhin die Antwort 403 Forbidden erhalten – das Ausblenden der Schaltflächen ist lediglich eine Anzeigeerleichterung; die tatsächliche Einschränkung erzwingt [RolesGuard] auf der Serverseite (Kapitel 3):

Image

Terminkalender, USER-Ansicht (schreibgeschützt, keine Aktionsschaltflächen)

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

Der „Debug“-Modus (Anzeige des rohen Templates der aktuellen View) des ursprünglichen AngularJS-1.x-Clients ist eine Funktion, die in dieser Portierung bewusst weggelassen wurde, genau wie in der [Angular]-Variante dieses Kurses – sie wird in einer späteren Phase des Kurses nicht auftauchen (zur Begründung dieser Entscheidung siehe Kapitel 6, Fazit). Die Einstellung einer künstlichen Netzwerkverzögerung wird dagegen tatsächlich in beiden Varianten auf eine spätere Phase verschoben.

Zwei weitere Unterschiede, die für diese [React]-Portierung spezifisch sind, verdienen hier Erwähnung:

  • Unit-Tests (die in diesem Projekt ebenso fehlen wie im [Angular]-Projekt dieses Kurses) würden in [React] einem anderen Ansatz folgen: Statt TestBed (spezifisch für [Angular]) stützt sich das [React]-Ökosystem typischerweise auf [React Testing Library] – in diesem Dokument nicht vorgestellt;
  • die Typprüfung für Templates ([Angular] strictTemplates, siehe vorheriges Kapitel) hat auf der Seite von [React] keine Entsprechung, die separat konfiguriert werden müsste: Der TypeScript-Compiler selbst prüft das [JSX], wie jede andere .tsx-Datei – eine Vereinfachung der Konfiguration, theoretisch auf Kosten einer etwas weniger tiefen Integration zwischen Template-Sprache und Typsystem (in der Praxis ist in diesem Projekt kein Unterschied beobachtbar).