Skip to content

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

Dieses Kapitel beschreibt Datei für Datei den Inhalt des diesem Dokument beiliegenden Ordners [rdvmedecins-vuejs-client] im Format, das im gesamten Kurs verwendet wird: zeilenweise nummerierter Quellcode, gefolgt von einem Abschnitt mit dem Titel „Kommentieren wir diesen Code:“. Jeder Projektordner enthält außerdem seine eigene [README.md].

6.1. Architekturüberblick

Wie im ursprünglichen Dokument und wie in den Varianten [Angular] und [React] dieses Kurses folgt der Client einer Schichtenarchitektur, die wir hier V-Services (View-Services) nennen.

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 [Vue.js] sind sie zu einer einzigen Einheit zusammengefasst, der Komponente [.vue] (siehe vorheriges Kapitel) – genau wie in [Angular] und [React], auch wenn die Form abweicht (eine Datei mit drei Blöcken statt einer Klasse oder einer Funktion) –, weshalb wir im Folgenden schlicht von „Komponenten“ sprechen, wo das ursprüngliche Dokument zwischen View und Controller unterschied.

Wie im ursprünglichen Dokument kommunizieren die Komponenten NIEMALS direkt über HTTP: Diese Rolle ist ausschließlich der Service-Schicht vorbehalten (hier das Composable [useAppointmentService()] und das Composable [useAuth()]). Dies ist ein Entwurfsprinzip, das gleichermaßen für AngularJS 1.x, [Angular], [React], oder [Vue.js] gilt – es hat sich nicht geändert.

6.2. Projektstruktur

Diese Struktur folgt unmittelbar dem Ablauf des ursprünglichen Dokuments (Login, Auswahl von Arzt/Datum, Anzeige des Terminkalenders, Terminbuchung) und ist hier lediglich in [Vue.js] -Komponenten gegliedert statt in getrennte Controller/Views von AngularJS 1.x, Standalone-Komponenten ([Angular]) oder funktionale Komponenten ([React]). Im Vergleich zu den beiden anderen Varianten dieses Kurses:

  • passt die Wurzelkomponente in eine einzige Datei (App.vue, plus README.md) statt in drei ([Angular]: app.ts/app.html/app.css) oder ebenfalls drei auf der [React]-Seite (App.tsx/App.css/README.md): [<template>] und [<script setup>] vereinen in derselben Datei, was [JSX] auf der [React]-Seite bereits vereint hatte – und App.vue hat, wie App.tsx, keine Konfigurationsdatei für die Anwendung, die app.config.ts entspräche;
  • Ein Ordner `core/composables/` tritt an die Stelle von `core/context/` auf der [React]-Seite (der auf der [Angular]-Seite selbst fehlt): Er enthält die Composables, die als injizierbare Services ([SettingsService], [AuthService], [LanguageService]) für die Variante [Angular] fungieren – dieser Mechanismus (Composables + [provide]/[inject]) wurde im vorherigen Kapitel zusammen mit einem generischen Beispiel eingeführt (siehe vorheriges Kapitel, „Geteilte Logik“).

[Bootstrap] 5 wird in allen Views verwendet (in main.ts importiert; siehe unten) – eine direkte Weiterentwicklung von Bootstrap 3, das bereits im ursprünglichen Dokument verwendet wurde, unverändert gegenüber den Varianten [Angular] und [React] dieses Kurses.

6.3. Konfigurationsdateien des Projekts

6.3.1. package.json

{
  "name": "rdvmedecins-vue-client",
  "version": "0.0.0",
  "scripts": {
    "dev": "vite",
    "start": "vite",
    "build": "vue-tsc -b && vite build",
    "preview": "vite preview"
  },
  "private": true,
  "packageManager": "npm@10.9.7",
  "dependencies": {
    "vue": "^3.5.0",
    "vue-i18n": "^11.0.0",
    "bootstrap": "^5.3.3"
  },
  "devDependencies": {
    "@vitejs/plugin-vue": "^5.2.0",
    "prettier": "^3.8.1",
    "typescript": "~5.8.0",
    "vite": "^6.0.0",
    "vue-tsc": "^2.2.0"
  }
}

Kommentieren wir diesen Code:

  • Zeilen 5–8: ["scripts": { … }] — die verfügbaren Befehle [npm run <name>]. [start] (wie dev) startet den [Vite]-Entwicklungsserver mit automatischem Neuladen, sobald eine Quelldatei geändert wird, auf Port 4200 (siehe vite.config.ts unten) – demselben Port wie bei den Varianten [Angular] und [React] dieses Kurses;
  • Zeile 7: ["build": "vue-tsc -b && vite build",] — bemerkenswerter Unterschied zu [React] ([tsc -b && vite build]): [vue-tsc] ersetzt den Standard-TypeScript-Compiler durch eine Variante, die auch die Typen INNERHALB von [<template>] prüfen kann (zum Beispiel ein [v-model] auf einer nicht existierenden Eigenschaft oder ein [:doctors] , das nicht zum von [defineProps] erwarteten Typ passt) – ähnlich wie [Angular] es mit seiner Option strictTemplates tut, während [React] das [JSX] einfach wie jedes andere TypeScript prüft;
  • Zeilen 12–16: ["dependencies": { … }] — die für die Ausführung im Browser erforderlichen Pakete: [vue] (der Kern des Frameworks), [vue-i18n] (Übersetzung FR/EN; siehe unten), [bootstrap] (nur das Stylesheet). Anders als bei den Varianten [Angular] und [React] dieses Kurses gibt es weder ein separates Äquivalent zu [@angular/router]/[react-i18next] (vue-i18n bringt seine Engine direkt mit; siehe i18n.ts) noch zu RxJS;
  • Zeilen 17–23: ["devDependencies": { … }] — nur während der Entwicklung benötigte Pakete: [@vitejs/plugin-vue] (Umwandlung der [.vue]-Dateien in JavaScript und Hot Reloading), TypeScript, [vue-tsc] (siehe oben) und [Vite] selbst. Anders als [React] ([@types/react], [@types/react-dom]) benötigt [Vue.js] keine separaten Typpakete: Die Bibliothek selbst ist in TypeScript geschrieben.

Anders als der [NestJS]-Server ([commonjs]-Modul, siehe Kapitel 3) läuft dieses Projekt mit nativen ECMAScript-Modulen (import/export) – genau wie die Varianten [Angular] und [React] dieses Kurses.

6.3.2. vite.config.ts

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

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

Kommentieren wir diesen Code:

  • Zeile 5: [plugins: [vue()],] — aktiviert die Umwandlung der [.vue]-Dateien (Trennung der drei Blöcke, Kompilierung des [<template>] je nach Rendermodus) und das Hot Reloading – das Äquivalent dessen, was [Vue.js] betrifft, zu dem, was [@vitejs/plugin-react]() für [JSX] auf der [React]-Seite leistete (siehe vorheriges Kapitel) und was [@angular/build:dev-server] für [Angular] im Hintergrund erledigt;
  • Zeilen 6–8: [server: { port: 4200, },] — legt den Port des Entwicklungsservers auf 4200 fest, denselben wie [ng serve] auf der [Angular]-Seite und wie beim [React]-Client dieses Kurses – eine rein didaktische Entscheidung, damit die drei Varianten dieses Kurses austauschbar bleiben, ohne dass Sie Ihren Arbeitsablauf ändern müssen.

Diese Datei hat im ursprünglichen AngularJS-1.x-Projekt kein Äquivalent; auf der [Angular]-Seite dieses Kurses erfüllt [angular.json] diese Aufgabe; auf der [NestJS]-Seite (Kapitel 3) ist es [nest-cli.json].

6.3.3. tsconfig.json

{
  "compilerOptions": {
    "target": "ES2022",
    "useDefineForClassFields": true,
    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "skipLibCheck": true,

    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "isolatedModules": true,
    "moduleDetection": "force",
    "noEmit": true,

    "strict": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true
  },
  "include": ["src"]
}

Zerlegen wir diesen Code:

  • Zeile 15: ["strict": true,] — wie [tsconfig.json] in den Varianten [Angular] und [React] dieses Kurses ist der vollständige Strict-Modus von TypeScript aktiv: Jede Variable muss einen bestimmbaren Typ haben, und jeder Wert null oder undefined muss explizit behandelt werden;
  • Zeilen 18–19: ["noUnusedLocals": true, "noUnusedParameters": true,] — markiert bei der Kompilierung jede Variable oder jeden Parameter, die deklariert, aber nie verwendet werden – dieselbe Einstellung wie bei [React];
  • Zeile 13: ["noEmit": true] — TypeScript wird hier nur zur Typ-PRÜFUNG verwendet ([npm run build] startet zuerst [vue-tsc -b], das bei einem Typfehler fehlschlägt, auch in einem [<template>]; siehe package.json oben): Das vom Browser ausgeführte JavaScript erzeugt tatsächlich [Vite] (über esbuild).

Anders als die Datei [tsconfig.json] , die für [React] ([jsx: ‘react-jsx’]) erzeugt wird, enthält diese Datei keine frameworkspezifischen Einstellungen: [vue-tsc] (und nicht der Standard-TypeScript-Compiler) legt vorab fest, wie eine [.vue]-Datei zu parsen ist – ein von dieser Konfigurationsdatei getrennter Mechanismus, anders als bei [React], wo die Unterstützung für [JSX] direkt hier konfiguriert wird.

6.4. Start der Anwendung

6.4.1. index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>RdvMedecins - Vue.js client</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="/favicon.ico">
</head>
<body>
  <div id="app"></div>
  <script type="module" src="/src/main.ts"></script>
</body>
</html>

Kommentieren wir diesen Code:

  • Zeile 2: [<html lang="en">] — genau wie bei [Angular] und [React] kann diese HTML-Seite, da sie statisch ist (vom Browser geladen, BEVOR die [Vue.js]-Anwendung startet), eine später vom Benutzer getroffene Sprachauswahl nicht sofort widerspiegeln;
  • Zeile 10: [<div id="app"></div>] — das einzige Element, das diese Seite anfangs enthält und das [Vue.js] nach dem Einhängen vollständig füllt (siehe main.ts unten) – das exakte Äquivalent zu <app-root></app-root> auf der [Angular]-Seite, zu <div id="root"></div> auf der [React]-Seite und zu [ng-app="rdvmedecinsApp"] im Tag <html> des ursprünglichen Dokuments (AngularJS 1.x, 2014); nur der Bezeichner ändert sich (Konvention von [Vue.js]: "app");
  • Zeile 11: [<script type="module" src="/src/main.ts"></script>] — wie bei [React] ist es index.html, die direkt auf main.ts verweist (eine Konvention von [Vite]) und nicht umgekehrt. In der Entwicklung transformiert und liefert [Vite] diese Datei im laufenden Betrieb; in der Produktion ([npm run build]) wird sie selbstverständlich vorher kompiliert.

Wie bei den beiden anderen Varianten gibt es für die gesamte Anwendung nur einen einzigen Einstiegspunkt: Das ist die eigentliche Definition einer Single-Page-Webanwendung (SPA), wie bereits im ursprünglichen Dokument beschrieben.

6.4.2. src/main.ts

import { createApp } from 'vue';

import 'bootstrap/dist/css/bootstrap.min.css';
import './index.css';

import { i18n } from './i18n';
import { createSettingsStore, SettingsKey } from './app/core/composables/settings.composable';
import { createAuthStore, AuthKey } from './app/core/composables/auth.composable';
import { createLanguageStore, LanguageKey } from './app/core/composables/language.composable';
import App from './app/App.vue';

const app = createApp(App);

app.use(i18n);

const settingsStore = createSettingsStore();
app.provide(SettingsKey, settingsStore);

const authStore = createAuthStore(settingsStore);
app.provide(AuthKey, authStore);

const languageStore = createLanguageStore();
app.provide(LanguageKey, languageStore);

const container = document.getElementById('app');
if (!container) {
  throw new Error('Element #app not found in index.html');
}

app.mount(container);

Kommentieren wir diesen Code:

  • Zeile 12: [const app = createApp(App);] — das direkte Äquivalent zu [bootstrapApplication(App, appConfig)] auf der [Angular]-Seite und zu [createRoot(...).render(...)] auf der [React]-Seite: [createApp(...)] erzeugt eine Anwendungsinstanz (hängt sie aber noch nicht ein; siehe Zeile 30);
  • Zeile 14: [app.use(i18n);] — installiert das [vue-i18n]-Plugin: Ab jetzt kann [useI18n()] im [<script setup>] jeder Komponente verwendet werden;
  • Zeilen 16–23: [const settingsStore = createSettingsStore(); app.provide(SettingsKey, settingsStore); …] — die drei [createXxxStore()] + [app.provide(...)] aus core/composables/ (siehe unten) machen [useSettings()], [useAuth()] und [useLanguage()] aus jeder untergeordneten Komponente nutzbar – das Äquivalent zu den drei [provideXxx()] aus [app.config.ts] auf der [Angular] -Seite ([providers: [...]]), hier aber als FOLGE von Funktionsaufrufen ausgedrückt statt als Array von Providern oder, auf der [React]-Seite, als VERSCHACHTELUNG von [Provider]-Komponenten um die Wurzelkomponente – hier ist keine sichtbare Verschachtelung nötig, anders als in [React] (vergleichen Sie mit main.tsx des React-Clients in diesem Kurs: <SettingsProvider><AuthProvider>...) ;
  • Zeilen 16, 19: [const settingsStore = … const authStore = createAuthStore(settingsStore);] — die REIHENFOLGE der Aufrufe ist wichtig: [createAuthStore(...)] setzt voraus, dass [settingsStore] bereits existiert (um [apiBaseUrl] zu lesen) – daher wird er direkt als Parameter übergeben und nicht über eine [Vue.js]-Injektion: In dieser Phase existieren noch keine Komponenten, sodass [inject()] nicht weiterhelfen würde;
  • Zeile 22: [const languageStore = createLanguageStore();] — wird NACH [app.use(i18n)] (Zeile 14) aufgerufen: Dieses Composable setzt voraus, dass das [vue-i18n]-Plugin bereits installiert ist;
  • Zeile 30: [app.mount(container);] — hängt die Anwendung tatsächlich in das Element #app der Datei index.html ein – getrennt von [createApp(App)] (Zeile 12), genau damit die dazwischenliegenden Zeilen (app.use, app.provide) die Anwendung konfigurieren können, bevor sie angezeigt wird.

Wie die Clients [Angular] und [React] in diesem Kurs (eine Seite, keine Routing-Tabelle) verwendet dieser Client, [Vue.js], KEINEN Router: App.vue zeigt je nach [useAuth().isLoggedIn] entweder den Anmeldebildschirm oder den Rest der Anwendung an – ein einfaches [v-if] genügt; ein Router ([vue-router] oder ein anderer) hätte für eine Single-Page-Anwendung keinen Mehrwert gebracht.

6.4.3. src/i18n.ts

import { createI18n } from 'vue-i18n';

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

const loadedDictionaries = new Set<Language>();

export const i18n = createI18n({
  legacy: false,
  locale: navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en',
  fallbackLocale: 'en',
  messages: {},
});

export async function loadDictionary(language: Language): Promise<void> {
  if (loadedDictionaries.has(language)) {
    return;
  }
  const httpResponse = await fetch(`/i18n/${language}.json`);
  const dictionary = (await httpResponse.json()) as Record<string, unknown>;
  i18n.global.setLocaleMessage(language, dictionary);
  loadedDictionaries.add(language);
}

Kommentieren wir diesen Code:

  • Zeile 8: [legacy: false,] — aktiviert den Modus „API Composition“ von [vue-i18n]: [useI18n()] in den Komponenten (wie [useTranslation()] auf der [React]-Seite) statt [this.$t] (der alte Modus, gedacht für die Options-API von [Vue.js] 2);
  • Zeilen 9–11: [locale: navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en', fallbackLocale: 'en', messages: {},] — Startsprache (Französisch, wenn die Browsersprache mit 'fr' beginnt, sonst Englisch), Rückfallsprache (Englisch), falls ein Schlüssel im aktuellen Wörterbuch fehlt, und beim Start leere Wörterbücher – [language.composable.ts] (siehe unten) ersetzt [locale] sofort durch die in localStorage gespeicherte Auswahl, falls vorhanden;
  • Zeilen 14–22: [export async function loadDictionary(language: Language): Promise<void> { …] — anders als [i18next-http-backend] (React) oder [TranslateHttpLoader] (Angular) stellt [vue-i18n] NICHT nativ einen „Loader“ bereit: Es wartet einfach darauf, dass ihm bereits geladene Wörterbücher über [setLocaleMessage(...)] geliefert werden. Diese Funktion baut daher manuell nach, was [HttpBackend] auf der [React]-Seite automatisch erledigte: Sie ruft mit [fetch] die Datei [/i18n/<language>.json] ab (EXAKT dieselbe URL wie bei den beiden anderen Varianten dieses Kurses) und speichert dann ihren Inhalt in [vue-i18n];
  • Zeilen 15–17: [if (loadedDictionaries.has(language)) { return; }] — verhindert, dass eine Sprache, die während der Sitzung bereits vorkam, erneut heruntergeladen wird – dieselbe Optimierung wie das interne Caching von [i18next-http-backend] auf der [React]-Seite.

6.4.4. src/index.css

body {
  background-color: #f5f7fa;
}

.free-slot {
  cursor: pointer;
}

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

Kommentieren wir diesen Code:

  • Zeile 1: [body { background-color: #f5f7fa; }] — identisch mit den beiden anderen Varianten: 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–11: [.free-slot { cursor: pointer; } .free-slot:hover { … }] — wird auf die Zeilen der Kalendertabelle angewendet, die einen freien Zeitslot darstellen (siehe Schedule.vue, [:class="scheduleSlot.appointment === null ? ‘free-slot’ : undefined"] unten): Der Cursor wird über die gesamte Zeile zur Hand, und der Hintergrund färbt sich beim Überfahren leicht grün – hier ist, anders als beim [React]-Client dieses Kurses (wo der „Pointer“-Cursor auf die Schaltfläche „Book“ selbst angewendet wurde), die gesamte Tabellenzeile anklickbar, wie im ursprünglichen Dokument vorgesehen.

Diese Datei enthält globale Stile, im Gegensatz zu den „lokalen“ Stilen, die eine [Vue.js]-Komponente in ihrem eigenen Block [<style scoped>] definieren kann (in diesem Projekt nicht verwendet: [Bootstrap] und index.css genügen für alles, was dieses Dokument umsetzt) – dasselbe Prinzip wie in [Angular] und [React] (getrennte Stildateien pro Komponente).

6.5. Die Schicht core/models

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

// Hülle, die allen Antworten des Servers gemeinsam ist (siehe ServerResponse<T> auf der NestJS-Seite)
export interface ServerResponse<T> {
  status: number; // 0 = Erfolg, alles andere = Fehler (siehe ResponseStatus auf der Server-Seite)
  data: T | null;
}

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

// [Client] bezeichnet hier einen PATIENTEN der Arztpraxis - nicht zu verwechseln mit „HTTP-Client"!
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; // Format "yyyy-MM-dd"
  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:

  • Die Interfaces selbst sind eine WÖRTLICHE Kopie aus den Varianten [Angular] und [React] dieses Kurses (lediglich neu geschrieben, wie der gesamte Client): Die TypeScript-Interfaces, die die mit dem Server ausgetauschten Daten beschreiben, hängen von keinem Framework ab – es ist „reines“ TypeScript, das genau der Klasse [ServerResponse]<T> und den [TypeORM]-Entitäten des [NestJS]-Servers entspricht (Kapitel 3);
  • [Role]/[LoginResult] – exakte 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 in allen drei Varianten dieses Kurses verwendet wird – wird ein Tippfehler in einem Feldnamen bereits vor dem Ausführen des Programms, direkt beim Kompilieren, gemeldet.

6.6. Die Schicht core/composables

Für diesen Client, [Vue.js], spielt dieses Verzeichnis dieselbe Rolle, die core/context/ beim Client [React] in diesem Kurs gespielt hat (siehe das vorige Kapitel, „Logik teilen“): Es fasst die drei Composables zusammen, die hier als injizierbare Services dienen ([SettingsService], [AuthService] und ein Teil des [LanguageService]) auf der [Angular]-Seite.

6.6.1. src/app/core/composables/settings.composable.ts

import { inject, reactive, type InjectionKey } from 'vue';

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

export const SettingsKey: InjectionKey<SettingsStore> = Symbol('SettingsStore');

export function createSettingsStore(): SettingsStore {
  const store = reactive<SettingsStore>({
    apiBaseUrl: 'http://localhost:8080',
    setApiBaseUrl(url: string) {
      store.apiBaseUrl = url;
    },
  });
  return store;
}

export function useSettings(): SettingsStore {
  const store = inject(SettingsKey);
  if (!store) {
    throw new Error('useSettings() must be called after app.provide(SettingsKey, ...) (see src/main.ts)');
  }
  return store;
}

Kommentieren wir diesen Code:

  • Zeile 8: [export const SettingsKey: InjectionKey<SettingsStore> = Symbol('SettingsStore');] – der Injektionsschlüssel (siehe vorheriges Kapitel) – ein typisiertes [Symbol] statt eines einfachen Strings;
  • Zeilen 10–18: [export function createSettingsStore(): SettingsStore { …] – ersetzt exakt [readonly apiBaseUrl = signal(‘http://localhost:8080’);] mit [SettingsService] auf der [Angular]-Seite: derselbe Standardwert, mit derselben Möglichkeit, ihn über das Feld „Server URL“ auf der Startseite des Originaldokuments zu ändern; [reactive(...)] (statt [ref()]) wird hier gewählt, weil der Store MEHRERE Eigenschaften enthält (apiBaseUrl und die zugehörige Aktualisierungsfunktion) – [store.apiBaseUrl] wird direkt gelesen und geschrieben, ohne [.value];
  • Zeilen 20–26: [export function useSettings(): SettingsStore { …] – das Composable, das die Komponenten aufrufen ([const settings = useSettings();]), das direkte Äquivalent zu [inject(SettingsService)] auf der [Angular]-Seite und zu [useSettings()] auf der [React]-Seite.

6.6.2. src/app/core/composables/auth.composable.ts

Portierung von [AuthService]: verwaltet die Anmeldung des Benutzers, ruft [POST /login] auf, speichert den erhaltenen JWT-Token (samt zugehöriger Identität/Rolle) und stellt mithilfe von [localStorage] sicher, dass er ein erneutes Laden der Seite übersteht. Dies ist die einzige Stelle in der Anwendung, die neben [core/services/appointment.service.ts] (siehe unten) per HTTP mit dem Server kommuniziert.

import { inject, reactive, type InjectionKey } from 'vue';
import type { LoginResult, ServerResponse, Role } from '../models/appointment.models';
import type { SettingsStore } from './settings.composable';

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;
  }
}

export interface AuthStore {
  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;
}

export const AuthKey: InjectionKey<AuthStore> = Symbol('AuthStore');

export function createAuthStore(settings: SettingsStore): AuthStore {
  const initialSession = readStoredSession();

  function applySession(session: StoredSession | null): void {
    store.isLoggedIn = session !== null;
    store.login = session?.login ?? null;
    store.name = session?.name ?? null;
    store.role = session?.role ?? null;
    store.isAdmin = session?.role === 'ADMIN';
    store.accessToken = session?.accessToken ?? null;
    if (session) {
      localStorage.setItem(STORAGE_KEY, JSON.stringify(session));
    } else {
      localStorage.removeItem(STORAGE_KEY);
    }
  }

  const store = reactive<AuthStore>({
    isLoggedIn: initialSession !== null,
    login: initialSession?.login ?? null,
    name: initialSession?.name ?? null,
    role: initialSession?.role ?? null,
    isAdmin: initialSession?.role === 'ADMIN',
    accessToken: initialSession?.accessToken ?? null,

    async logIn(login: string, password: string): Promise<LoginResult> {
      const httpResponse = await fetch(`${settings.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;
      applySession(result);
      return result;
    },

    logOut(): void {
      applySession(null);
    },
  });

  return store;
}

export function useAuth(): AuthStore {
  const store = inject(AuthKey);
  if (!store) {
    throw new Error('useAuth() must be called after app.provide(AuthKey, ...) (see src/main.ts)');
  }
  return store;
}

Gehen wir diesen Code durch:

  • Zeilen 14–21: [function readStoredSession(): StoredSession | null { …] – durch einen try/catch-Block geschützt, genau wie bei [Angular] und [React]: [localStorage] kann nicht verfügbar sein (sehr restriktiver privater Modus) oder einen beschädigten Wert enthalten – in diesem Fall nehmen wir einfach an, dass es keine Sitzung gibt;
  • Zeile 37: [const initialSession = readStoredSession();] – wird nur einmal aufgerufen, wenn der Store erzeugt wird (in src/main.ts) – genau dieselbe Rolle, die der Initialisierer [useState(readStoredSession)] auf der [React]-Seite oder [signal(readStoredSession())] auf der [Angular]-Seite spielt. Lädt der Benutzer die Seite nach der Anmeldung neu, bleibt er angemeldet;
  • Zeilen 39–51: [function applySession(session: StoredSession | null): void { …] – fasst zusammen, was [logIn()] und [logOut()] gemeinsam haben: die Aktualisierung der reaktiven Eigenschaften des Stores UND die Synchronisierung von [localStorage] in einem einzigen Schritt – eine kleine interne Funktion, die in der entsprechenden Version [React] fehlt (die diese Logik mangels eines ähnlich natürlichen gemeinsamen Schreibpunkts in jeder der beiden Funktionen wiederholte);
  • Zeilen 53–79: [const store = reactive<AuthStore>({ … });] – dasselbe Prinzip wie bei settings.composable.ts: ein einziges [reactive]-Objekt, dessen Eigenschaften (isLoggedIn, login, accessToken …) von [applySession()] DIREKT verändert statt durch ein neues Objekt ersetzt werden – anders als [AuthContext] auf der [React]-Seite, das bei jeder Änderung mit [value] per [useMemo]() ein neues Objekt aufbauen muss (siehe vorheriges Kapitel), [Vue.js] braucht das hier nicht: Nur die Komponenten, die eine tatsächlich geänderte Eigenschaft lesen, werden automatisch neu gezeichnet;
  • Zeilen 61–74: [async logIn(login: string, password: string): Promise<LoginResult> { …] – entspricht: POST /login, Body JSON { login, password }; wie auf der [React]-Seite (fetch/async-await) laufen die Schritte ganz natürlich von oben nach unten ab, ohne einen eigenen RxJS-Operator (anders als [AuthService.logIn()] auf der [Angular]-Seite, das ein Observable zurückgibt und die Sitzung in einem separaten tap()-Operator speichert);
  • Zeilen 76–78: [logOut(): void { applySession(null); },] – rein lokal (kein Serveraufruf): Ein JWT-Token wird in dieser Portierung serverseitig nicht „widerrufen“; er läuft nach JWT_EXPIRES_IN von selbst ab (siehe die .env des Servers, Kapitel 3).

6.6.3. src/app/core/composables/language.composable.ts

Portierung eines Teils von [LanguageService]: zentralisiert den Wechsel der Oberflächensprache (Französisch/Englisch) auf Basis von [vue-i18n] (siehe i18n.ts oben).

import { inject, reactive, watch, type InjectionKey } from 'vue';
import { loadDictionary, i18n, type Language } from '../../../i18n';

const STORAGE_KEY = 'rdvmedecins.language';

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

export const LanguageKey: InjectionKey<LanguageStore> = Symbol('LanguageStore');

export function createLanguageStore(): LanguageStore {
  const store = reactive<LanguageStore>({
    currentLanguage: i18n.global.locale.value as Language,
    changeLanguage(language: Language) {
      localStorage.setItem(STORAGE_KEY, language);
      applyLanguage(language);
    },
  });

  function applyLanguage(language: Language): void {
    void loadDictionary(language).then(() => {
      i18n.global.locale.value = language;
      document.documentElement.lang = language;
    });
  }

  watch(i18n.global.locale, (newLanguage) => {
    store.currentLanguage = newLanguage as Language;
  });

  const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null;
  if (savedLanguage && savedLanguage !== store.currentLanguage) {
    applyLanguage(savedLanguage);
  } else {
    applyLanguage(store.currentLanguage);
  }

  return store;
}

export function useLanguage(): LanguageStore {
  const store = inject(LanguageKey);
  if (!store) {
    throw new Error('useLanguage() must be called after app.provide(LanguageKey, ...) (see src/main.ts)');
  }
  return store;
}

Kommentieren wir diesen Code:

  • Zeile 15: [currentLanguage: i18n.global.locale.value as Language,] – [vue-i18n] stellt seine aktuelle Sprache bereits als reaktives [ref] ([i18n.global.locale]) bereit: [LanguageStore] legt keinen eigenen Zustand an, sondern VERÖFFENTLICHT ihn lediglich unter einem stabilen Namen erneut (currentLanguage) – exakt dasselbe Konzept wie bei [Angular], wo [LanguageService] lediglich [this.translate.currentLang] unter einem anderen Namen erneut veröffentlichte;
  • Zeilen 22–27: [function applyLanguage(language: Language): void { …] – [loadDictionary(language)] (siehe i18n.ts) holt bei Bedarf das zugehörige Wörterbuch, DANN, sobald es vorliegt, wird auf [i18n.global.locale.value] umgeschaltet – anders als bei [i18n.changeLanguage(...)] auf der [React]-Seite (das beides auf einmal erledigt); da [vue-i18n] hier keinen eingebauten „Loader“ besitzt (siehe i18n.ts), orchestriert dieses Composable beide Schritte selbst;
  • Zeilen 29–31: [watch(i18n.global.locale, (newLanguage) => { store.currentLanguage = newLanguage as Language; });] – [watch(source, callback)] führt den Callback jedes Mal erneut aus, wenn sich der beobachtete Wert ändert – für eine einzelne Eigenschaft das Äquivalent zu [useEffect](..., [dep]) auf der [React]-Seite oder zu [effect()] auf der [Angular]-Seite. Diese Zeile führt die zu Beginn dieser Datei erwähnte „erneute Veröffentlichung“ tatsächlich aus: [store.currentLanguage] bleibt IMMER synchron mit [i18n.global.locale], unabhängig davon, wie sich Letzteres geändert hat;
  • Zeilen 33–38: [const savedLanguage = localStorage.getItem(STORAGE_KEY) as Language | null; …] – beim allerersten Laden: Hat der Benutzer bei einem früheren Besuch bereits eine Sprache gewählt, wird sie wiederhergestellt; andernfalls bleibt die in i18n.ts festgelegte Startsprache erhalten (Englisch, bzw. Französisch bei einem französischen Browser) – aber DEREN Wörterbuch muss trotzdem noch geladen werden, was i18n.ts nicht selbst übernimmt – genau die Rolle, die [useEffect](..., []) in language.context.tsx auf der [React]-Seite spielt und das nur einmal beim Setup ausgeführt wird.

Entspricht dem Button „FR / EN“ im ursprünglichen AngularJS-1.x-Client, der damals auf der Bibliothek [angular-translate] beruhte – dem Vorgänger von [ngx-translate] ([Angular]) innerhalb des AngularJS-1.x-Ökosystems, gefolgt von [i18next] ([React]) und [vue-i18n] ([Vue.js]).

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

[loadDictionary()] (siehe i18n.ts oben) lädt eine dieser beiden Dateien über eine [HTTP GET /i18n/<language>.json]-Anfrage, sobald sich die Sprache ändert (oder sie zum ersten Mal verwendet wird). [vue-i18n] löst dann jeden Schlüssel ("LOGIN.TITLE", "SCHEDULE.FREE" …) über den [useI18n() (function t(...))]-Hook auf, der in allen Komponenten des Verzeichnisses features/ verwendet wird (siehe später in diesem Kapitel).

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / Vue.js",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "SUBMITTING": "Connexion...",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
    "DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
    "DEMO_ACCOUNTS_OR": "ou",
    "DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
  },
  "DOCTOR_DAY_PICKER": { "...": "..." },
  "SCHEDULE": { "...": "..." },
  "BOOKING_DIALOG": { "...": "..." }
}

Kommentieren wir diesen Code:

  • Diese Datei spiegelt Schlüssel für Schlüssel die Dateien der Varianten [Angular] und [React] dieses Kurses wider (dieselben Abschnitte wie in DOCTOR_DAY_PICKER/SCHEDULE/BOOKING_DIALOG, hier aus Platzgründen nicht wiedergegeben; Einzelheiten siehe die mitgelieferte Datei), mit zwei Ausnahmen: Zeile 3 ([TITLE]), die sich jetzt auf [Vue.js] statt auf [React] bezieht; und vier neue Schlüssel ([DEMO_ACCOUNTS_*], Zeilen 14–17), die von Login.vue (siehe unten) angezeigt werden, um die beiden Demo-Konten direkt auf dem Anmeldebildschirm zu zeigen – eine kleine Komfortfunktion, die in den beiden anderen Versionen dieses Kurses nicht enthalten ist;
  • Ein verschachteltes JSON-Objekt, ein Abschnitt pro Komponente; [vue-i18n] flacht es zu einem flachen Wörterbuch ab, in dem jeder vollständige Schlüssel ("LOGIN.TITLE") durch Verkettung des Pfades mit Punkten gebildet wird – genau wie [i18next] es bei [React] und [TranslateService] es bei [Angular] tut.

6.7.2. public/i18n/en.json

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

Gehen wir diesen Code durch:

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

Beide Dateien müssen strukturell identisch bleiben (dieselben Schlüssel in beiden): So ist sichergestellt, dass ein Schlüssel in beiden Sprachen existiert. Die Teile, die NICHT übersetzt werden, bleiben gegenüber den Varianten [Angular] und [React] dieses Kurses unverändert: Fehlermeldungen des Servers [NestJS] bleiben unabhängig von der auf der Client-Seite gewählten Sprache auf Englisch, und die Namen der Ärzte und Patienten stammen direkt aus der Datenbank.

6.8. Die Schicht core/interceptors

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

Weder [Vue.js] noch [React] besitzt einen eingebauten HTTP-Interceptor wie [HttpClient]/[withInterceptors([...])] auf der [Angular]-Seite. Diese Datei implementiert dasselbe Konzept neu, und zwar als Composable, das [fetch] kapselt: Das ist das moderne Äquivalent zu den $http-Interceptoren von AngularJS 1.x, denen wir im Originaldokument bereits begegnet sind (Kapitel „Beispiel 6“).

import { useAuth } from '../composables/auth.composable';

export function useAuthFetch(): (path: string, options?: RequestInit) => Promise<Response> {
  const auth = useAuth();

  return async function authFetch(path: string, options: RequestInit = {}): Promise<Response> {
    const headers = new Headers(options.headers);
    if (auth.accessToken) {
      headers.set('Authorization', `Bearer ${auth.accessToken}`);
    }

    const response = await fetch(path, { ...options, headers });

    if (response.status === 401) {
      auth.logOut();
    }

    return response;
  };
}

Gehen wir diesen Code durch:

  • Zeile 3: [export function useAuthFetch(): (path: string, options?: RequestInit) => Promise<Response> {] – anders als [authInterceptor] auf der [Angular]-Seite (eine Funktion, die ein für alle Mal in [app.config.ts] registriert und dann automatisch auf jeden Aufruf von [HttpClient] angewendet wird), ist [useAuthFetch()] ein Composable, das jeder Aufrufer (hier [useAppointmentService()], siehe unten) ausdrücklich aufrufen und anstelle von [fetch()] verwenden muss – derselbe Ansatz wie auf der [React]-Seite; anders als bei [React] ([useCallback](...)) muss die zurückgegebene Funktion hier nicht gespeichert werden: Der Rumpf eines [<script setup>] wird nur EINMAL pro Komponenteninstanz ausgeführt und daher auch nur einmal erzeugt;
  • Zeilen 8–10: [if (auth.accessToken) { headers.set(‘Authorization’, …); }] – das direkte Äquivalent zu [request.clone({ setHeaders: { Authorization: … } })] auf der [Angular]-Seite. Anders als bei einer [HttpClient]-Anfrage (die unveränderlich ist) sind die Optionen von [fetch] einfach ein JavaScript-Objekt: Es ist nicht nötig, davon eine „geklonte“ Kopie zu erstellen; es genügt, das Objekt [headers] vor dem Aufruf aufzubauen;
  • Zeilen 14–16: [if (response.status === 401) { auth.logOut(); }] – dasselbe Prinzip wie bei [Angular] (catchError + HttpErrorResponse.status === 401): Ein 401 während einer Sitzung bedeutet, dass der Token nicht mehr gültig ist; der Client wird ordnungsgemäß abgemeldet; [fetch] weist sein Promise bei einem HTTP-Status nicht als Fehler zurück (anders als ein Observable [HttpClient]) – deshalb prüft dieser Test direkt [response.status], ohne try/catch-Block;
  • Zeile 18: [return response;] – die Antwort (möglicherweise ein 401) wird dennoch unverändert an den Aufrufer zurückgegeben, der weiterhin für die Behandlung der Folgen zuständig ist (siehe useAppointmentService(), extract<T>(), unten) – Der Interceptor darf den Fehler nicht vor dem aufrufenden Code verbergen.

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

6.9. Die Schicht core/services

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

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

import { useAuthFetch } from '../interceptors/auth.interceptor';
import { useSettings } from '../composables/settings.composable';
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 responded with error status ${envelope.status}`);
  }
  return envelope.data as T;
}

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

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

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

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

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

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

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

Kommentieren wir diesen Code:

  • Zeile 5: [async function extract<T>(httpResponse: Response): Promise<T> {] – statt in jeder öffentlichen Funktion das „wenn status !== 0, liegt ein Fehler vor“ zu wiederholen, wird es hier nur ein einziges Mal zentralisiert – genau die Rolle von [AppointmentService.extract()] bei [Angular] und von [extract<T>()] bei [React];
  • Zeile 13: [export function useAppointmentService() {]– ein Composable, das genau wie [inject(AppointmentService)] auf der [Angular]-Seite gelesen und verwendet wird: Es wird einmal am Anfang des [<script setup>] einer Komponente aufgerufen, und anschließend werden die zurückgegebenen Funktionen benutzt;
  • Zeilen 17–20: [async function getAllDoctors(): Promise<Doctor[]> { …] – anders als bei [React] ([useCallback](..., [authFetch, apiBaseUrl])) muss keine dieser Funktionen zwischen Renderings zwischengespeichert werden: Ein [<script setup>] [Vue.js] wird nur einmal pro Komponenteninstanz ausgeführt (siehe auth.interceptor.ts oben) – dieses technische Detail, das auf der [React]-Seite nötig ist, entfällt hier vollständig;
  • 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 von Server- und Client-Seite erleichtert, genau wie bei [Angular] und [React].

Anders als bei [AuthStore.logIn()] (vorheriges Kapitel) muss keine der Methoden dieses Composables nach dem Aufruf Daten behalten: Die aufrufende Komponente (App.vue) entscheidet, was mit dem Ergebnis geschieht (doctors.value = result, schedule.value = result …) – dieselbe Aufgabentrennung wie bei [Angular] und [React], wo [AppointmentService] und [useAppointmentService()] nichts über den auf dem Bildschirm angezeigten Zustand wissen.

6.10. Die Features-Schicht: die vier Komponenten

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

Portierung von [login.component.ts/.html] ([Angular]) und [Login.tsx] ([React]): der Anmeldebildschirm, Äquivalent zur View [login.html] des ursprünglichen AngularJS-1.x-Clients (die erste von der Anwendung angezeigte View). Diese Komponente kennt weder den Terminkalender noch die Termine: Sie erfasst lediglich ein Paar (Benutzername, Passwort), reicht es an [AuthStore.logIn(...)] weiter und zeigt etwaige Fehler an.

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import { useAuth } from '../../core/composables/auth.composable';

const { t } = useI18n();
const auth = useAuth();

const login = ref('');
const password = ref('');
const submitting = ref(false);
const error = ref<string | null>(null);

async function onSubmit(): Promise<void> {
  if (login.value.trim() === '' || password.value === '') {
    return;
  }
  error.value = null;
  submitting.value = true;
  try {
    await auth.logIn(login.value, password.value);
    submitting.value = false;
  } catch {
    submitting.value = false;
    error.value = 'LOGIN.ERROR';
  }
}
</script>

<template>
  <div class="row justify-content-center">
    <div class="col-sm-8 col-md-6 col-lg-4">
      <form class="card p-4" @submit.prevent="onSubmit">
        <h5 class="card-title mb-3">{{ t('LOGIN.TITLE') }}</h5>

        <div v-if="error" class="alert alert-danger py-2" role="alert">
          {{ t(error) }}
        </div>

        <div class="mb-3">
          <label class="form-label" for="input-login">
            {{ t('LOGIN.LOGIN_LABEL') }}
          </label>
          <input id="input-login" type="text" class="form-control"
            autocomplete="username" v-model="login" />
        </div>

        <div class="mb-3">
          <label class="form-label" for="input-password">
            {{ t('LOGIN.PASSWORD_LABEL') }}
          </label>
          <input id="input-password" type="password" class="form-control"
            autocomplete="current-password" v-model="password" />
        </div>

        <button type="submit" class="btn btn-primary w-100" :disabled="submitting">
          {{ submitting ? t('LOGIN.SUBMITTING') : t('LOGIN.SUBMIT') }}
        </button>

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

Gehen wir diesen Code durch:

  • Zeile 6: [const { t } = useI18n();] – eine eigenständige [Angular] -Komponente deklariert in ihrem Dekorator [@Component] die Pipes, die sie verwendet ([imports: [TranslatePipe]]); eine [Vue.js]-Komponente muss wie eine [React]-Komponente nichts Vergleichbares deklarieren: [useI18n()] wird einfach importiert und aufgerufen, wie jede andere Funktion;
  • Zeilen 9–12: [const login = ref(''); const password = ref(''); …] – ein rein lokaler Zustand des Formulars (das, was der Benutzer gerade eingibt) – das Äquivalent zu den lokalen [signal()]-Werten der [Angular]-Komponente und zu [useState()] auf der [React]-Seite (hier ein [ref] nach Wert statt eines [value, setValue]-Paares);
  • Zeile 33: [@submit.prevent="onSubmit"] – ein bewusster Unterschied zur [Angular]-Variante dieses Kurses: Statt jedes Feld einzeln zu überwachen (keyup.enter), verwendet diese Komponente ein echtes <form>-Element und dessen natives Ereignis [submit] – sowohl die Eingabetaste als auch ein Klick auf den Button „Log in“ (type="submit") lösen dann [onSubmit()] aus; der Modifikator [.prevent] verhindert automatisch das Standardverhalten des Browsers (das Neuladen der Seite) – das Äquivalent zum expliziten clientseitigen [event?.preventDefault()], aber direkt im [<template>] ausgedrückt statt im TypeScript-Code;
  • Zeilen 44–45: [autocomplete="username" v-model="login"] – [v-model] verbindet das Feld und das [login]-[ref] in beide Richtungen (Lesen UND Schreiben) in einem einzigen Attribut – eine Vereinfachung gegenüber [React] ([value={login} onChange={(e) => setLogin(e.target.value)}], zwei getrennte Attribute) und [Angular] ([[(ngModel)]] oder [[value]]+(input), je nach Fall);
  • Zeilen 23–26: [catch { submitting.value = false; error.value = ‘LOGIN.ERROR’; }] – ein ungültiges Paar aus Benutzername und Passwort lässt [logIn()] mit einer JavaScript-Ausnahme scheitern (ausgelöst von auth.composable.ts, siehe oben): Dem Benutzer wird „LOGIN.ERROR“ angezeigt, ohne zwischen einem nicht existierenden Benutzernamen und einem falschen Passwort zu unterscheiden – genau derselbe Ansatz wie bei [Angular] und [React]. Einen Übersetzungsschlüssel statt eines bereits aufgelösten Textes zu speichern, hat denselben Vorteil wie in den beiden anderen Varianten: Wechselt der Benutzer die Sprache, während diese Meldung angezeigt wird, übersetzt sie sich automatisch ([t(error)], Zeile 37, automatisch neu ausgewertet).

Diese Komponente vereint in EINER [.vue]-Datei, was [Angular] auf zwei aufteilt (login.component.ts für die Logik, login.component.html für das Template): [<template>] ist für das Template da, [<script setup>] für die Logik in derselben Datei – genau wie [Login.tsx] es auf der [React]-Seite bereits mit dem [JSX] tat, das seine Funktion zurückgibt.

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

Portierung von [doctor-day-picker.component.ts/.html] ([Angular]) und [DoctorDayPicker.tsx] ([React]): die Komponente, mit der Sie einen Arzt und ein Datum auswählen und anschließend dessen Terminkalender anfordern können. Konzeptionell entspricht sie den Beispielen 7 bis 10 des ursprünglichen AngularJS-1.x-Clients.

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import type { Doctor } from '../../core/models/appointment.models';

defineProps<{
  doctors: Doctor[];
}>();

const emit = defineEmits<{
  search: [criteria: { doctorId: number; day: string }];
}>();

const { t } = useI18n();

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

function onSearchClick(): void {
  if (selectedDoctorId.value === null) {
    return;
  }
  emit('search', { doctorId: selectedDoctorId.value, day: selectedDay.value });
}
</script>

<template>
  <div class="card p-3 mb-3">
    <div class="row g-2 align-items-end">
      <div class="col-sm-5">
        <label class="form-label" for="select-doctor">
          {{ t('DOCTOR_DAY_PICKER.DOCTOR_LABEL') }}
        </label>
        <select id="select-doctor" class="form-select" v-model="selectedDoctorId">
          <option :value="null">{{ t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR') }}</option>
          <option v-for="doctor in doctors" :key="doctor.id" :value="doctor.id">
            {{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}
          </option>
        </select>
      </div>

      <div class="col-sm-4">
        <label class="form-label" for="input-day">
          {{ t('DOCTOR_DAY_PICKER.DAY_LABEL') }}
        </label>
        <input id="input-day" type="date" class="form-control" v-model="selectedDay" />
      </div>

      <div class="col-sm-3">
        <button type="button" class="btn btn-primary w-100"
          :disabled="selectedDoctorId === null" @click="onSearchClick">
          {{ t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE') }}
        </button>
      </div>
    </div>
  </div>
</template>

Gehen wir diesen Code durch:

  • Zeilen 6–8: [defineProps<{ doctors: Doctor[]; }>();] – ein [input.required<Doctor[]>()] [Angular] wird zu einer PROP [Vue.js]; anders als bei [React] (ein destrukturiertes `props`-Objekt ohne gesonderte Typdeklaration) ist [defineProps<...>()] eine Funktion, die der Compiler zur Kompilierzeit als [Vue.js] erkennt: Im endgültigen JavaScript existiert sie nicht einmal mehr;
  • Zeilen 10–12: [const emit = defineEmits<{ search: [criteria: { … }]; }>();] – ein [output<...>()] [Angular] wird hier zu einem deklarierten EREIGNIS – [App.vue] hört darauf mit [@search="onSearchSchedule"] (siehe unten), genau wie es das Ereignis (search) des [Angular]-Templates abonnierte; bei [React]war es eine einfache Funktions-Prop ([onSearch]) – [Vue.js] unterscheidet hier wie [Angular] ausdrücklicher zwischen Ein- und Ausgaben;
  • Zeilen 21–26: [function onSearchClick(): void { … emit(‘search’, { … }); }] – [emit(‘search’, ...)] löst das Ereignis aus – das direkte Äquivalent zu [search.emit(...)] auf der [Angular]-Seite und zum als Prop empfangenen Funktionsaufruf ([onSearch(...)]) auf der [React]-Seite;
  • Zeile 36: [select id="select-doctor" class="form-select" v-model="selectedDoctorId"] – [v-model] auf einem <select> verknüpft den ausgewählten Wert direkt mit [selectedDoctorId.value] – eine Vereinfachung gegenüber [React] (getrenntes :value und @change, siehe vorheriges Kapitel) und gegenüber [Angular] ([(ngModel)] oder [value]+(change), je nach Fall);
  • Zeilen 38–40: [option v-for="doctor in doctors" :key="doctor.id" :value="doctor.id"] – [v-for] + [:key] ist das [Vue.js]-Äquivalent zu [.map(...)] + [key={...}] auf der [React]-Seite (und zu [@for (doctor of doctors(); track doctor.id)] auf der [Angular]-Seite): In allen drei Fällen legt ein stabiler Bezeichner fest, wie ein bereits angezeigter Arzt wiedererkannt wird, wenn er neu gezeichnet wird.

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

Portierung von [schedule.component.ts/.html] ([Angular]) und [Schedule.tsx] ([React]): 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 erhält diese Komponente zusätzlich [canEdit]: Ist der Wert false (Rolle USER), verschwinden die Buttons „Book“/„Cancel“ – der Terminkalender bleibt einsehbar, aber im Nur-Lese-Modus.

<script setup lang="ts">
import { useI18n } from 'vue-i18n';
import type { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';

defineProps<{
  schedule: DoctorDaySchedule | null;
  canEdit: boolean;
}>();

const emit = defineEmits<{
  book: [slot: SlotJson];
  cancel: [appointment: AppointmentJson];
}>();

const { t } = useI18n();

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

function onSlotClick(scheduleSlot: ScheduleSlot, canEdit: boolean): void {
  if (!canEdit) {
    return;
  }
  if (scheduleSlot.appointment === null) {
    emit('book', scheduleSlot.slot);
  } else {
    emit('cancel', scheduleSlot.appointment);
  }
}
</script>

<template>
  <p v-if="schedule === null" class="text-muted">{{ t('SCHEDULE.EMPTY_STATE') }}</p>

  <div v-else class="card p-3">
    <h5>
      {{ t('SCHEDULE.TITLE_PREFIX') }} {{ schedule.day }} - {{ schedule.doctor.title }}
      {{ schedule.doctor.firstName }} {{ schedule.doctor.lastName }}
    </h5>

    <table class="table table-hover align-middle">
      <thead>
        <tr>
          <th>{{ t('SCHEDULE.COLUMN_SLOT') }}</th>
          <th>{{ t('SCHEDULE.COLUMN_STATUS') }}</th>
          <th></th>
        </tr>
      </thead>
      <tbody>
        <tr v-for="scheduleSlot in schedule.slots" :key="scheduleSlot.slot.id"
          :class="scheduleSlot.appointment === null ? 'free-slot' : undefined">
          <td>
            {{ formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute) }} -
            {{ formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute) }}
          </td>
          <td>
            <span v-if="scheduleSlot.appointment === null" class="badge text-bg-success">
              {{ t('SCHEDULE.FREE') }}
            </span>
            <span v-else class="badge text-bg-secondary">
              {{ scheduleSlot.appointment.client?.title }} {{ scheduleSlot.appointment.client?.firstName }}
              {{ scheduleSlot.appointment.client?.lastName }}
            </span>
          </td>
          <td>
            <button v-if="canEdit" type="button"
              :class="'btn btn-sm ' + (scheduleSlot.appointment === null ? 'btn-outline-success' : 'btn-outline-danger')"
              @click="onSlotClick(scheduleSlot, canEdit)">
              {{ scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT') }}
            </button>
          </td>
        </tr>
      </tbody>
    </table>
  </div>
</template>

Kommentieren wir diesen Code:

  • Zeilen 34, 36: [p v-if="schedule === null" … div v-else …] – [v-if]/[v-else] ersetzen das „frühe Return“, das in [React] ([if (schedule === null) return <p>...</p>;]) verwendet wird: Solange keine Suche durchgeführt wurde (oder der Terminkalender leer ist), wird nur die Meldung für den leeren Zustand in das DOM aufgenommen, ohne dass die darauffolgende Tabelle überhaupt erst aufgebaut wird;
  • Zeile 7: [canEdit: boolean;] – eine durch die Authentifizierung eingeführte Neuerung, ähnlich wie bei [Angular] und [React]: App.vue übergibt ihr [auth.isAdmin] (siehe unten). Ist der Wert false (Rolle USER), existiert der Button „Book“/„Cancel“ im DOM gar nicht erst (Zeile 67, [v-if="canEdit"]) – er ist nicht nur ausgegraut oder deaktiviert, sondern fehlt vollständig;
  • Zeilen 58–64: [span v-if="scheduleSlot.appointment === null" … span v-else …] – [v-if]/[v-else] ersetzen den ternären Operator, der auf der [React]-Seite verwendet wird – grünes [Bootstrap]-Badge („Free“) oder graues (Name des Patienten), je nach Zustand des Zeitfensters;
  • Zeile 67: [button v-if="canEdit" type="button"] – anders als bei [React] (dem Operator [&&], {canEdit && (…)}) genügt in [v-if] allein [Vue.js] hier: Es gibt in [Vue.js] kein Äquivalent zu [&&] für „nur anzeigen, wenn wahr, sonst nichts“ – [v-if] leistet genau das von allein;
  • Zeile 70: [{{ scheduleSlot.appointment === null ? t('SCHEDULE.BOOK') : t('SCHEDULE.CANCEL_APPOINTMENT') }}] – wie auf der [Angular]-Seite (wo eine Pipe in jedem Template-Ausdruck verwendet werden kann) und auf der [React]-Seite ist [t(...)] eine gewöhnliche JavaScript-Funktion: Sie kann ohne besondere Syntax direkt in einem [{{ }}]-Ausdruck verwendet werden.

Diese Komponente führt selbst keine HTTP-Aufrufe aus: Sie zeigt die über Props erhaltenen Daten an und teilt ihrem Elternelement (App.vue) die Absichten des Benutzers über die [book]/[cancel]-Ereignisse mit – genau dieselbe Aufgabentrennung wie bei [Angular] und [React].

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

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

<script setup lang="ts">
import { ref } from 'vue';
import { useI18n } from 'vue-i18n';
import type { Client, SlotJson } from '../../core/models/appointment.models';

defineProps<{
  open: boolean;
  slot: SlotJson | null;
  clients: Client[];
}>();

const emit = defineEmits<{
  confirm: [choice: { clientId: number }];
  close: [];
}>();

const { t } = useI18n();
const selectedClientId = ref<number | null>(null);

function onConfirmClick(): void {
  if (selectedClientId.value === null) {
    return;
  }
  emit('confirm', { clientId: selectedClientId.value });
  selectedClientId.value = null;
}

function onCloseClick(): void {
  selectedClientId.value = null;
  emit('close');
}
</script>

<template>
  <template v-if="open">
    <div class="modal-backdrop fade show"></div>

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

          <div class="modal-body">
            <p v-if="slot">
              {{ 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>

            <label class="form-label" for="select-client">
              {{ t('BOOKING_DIALOG.PATIENT_LABEL') }}
            </label>
            <select id="select-client" class="form-select" v-model="selectedClientId">
              <option :value="null">{{ t('BOOKING_DIALOG.CHOOSE_PATIENT') }}</option>
              <option v-for="client in clients" :key="client.id" :value="client.id">
                {{ client.title }} {{ client.firstName }} {{ client.lastName }}
              </option>
            </select>
          </div>

          <div class="modal-footer">
            <button type="button" class="btn btn-secondary" @click="onCloseClick">
              {{ t('BOOKING_DIALOG.CANCEL') }}
            </button>
            <button type="button" class="btn btn-primary"
              :disabled="selectedClientId === null" @click="onConfirmClick">
              {{ t('BOOKING_DIALOG.CONFIRM') }}
            </button>
          </div>
        </div>
      </div>
    </div>
  </template>
</template>

Gehen wir diesen Code durch:

  • Zeile 35: [template v-if="open"] – ein [<template>] (ein [Vue.js]-spezifisches Tag, das SELBST kein Element erzeugt) trägt das [v-if]: Bis das Modal geöffnet wird, wird nichts in das DOM geladen – das exakte Äquivalent zu [if (!open) return null;] auf der [React]-Seite und zu [@if(open())] auf der [Angular]-Seite;
  • Zeile 36: [div class="modal-backdrop fade show"] – der halbtransparente Hintergrund, der den Rest der Seite abdunkelt – hier fest codiert, wie in den beiden anderen Varianten, während [Bootstrap] ihn beim Anzeigen des Modals normalerweise selbst per JavaScript einfügt;
  • Zeile 38: [div class="modal fade show d-block"] – [d-block] übernimmt die Rolle, die normalerweise das JavaScript von [Bootstrap] erfüllt (beim Öffnen [display:block] hinzufügen) – Hier übernimmt diese Rolle direkt das [v-if] aus Zeile 35;
  • Zeile 44: [:aria-label="t(‘BOOKING_DIALOG.CLOSE_ARIA’)"] – anders als [attr.aria-label="‘BOOKING_DIALOG.CLOSE_ARIA’ | translate"] auf der [Angular]-Seite (ein Attribut-Binding, das von der Interpolation {{ }} getrennt ist) und ähnlich wie bei [JSX] und [React] (die zwischen einem Attribut und dem Inhalt eines Elements nicht unterscheiden) verwendet [Vue.js] hier [:aria-label="..."] – das Präfix [:] kennzeichnet ein Attribut-BINDING (einen JavaScript-Ausdruck) statt eines literalen Strings.

Wie in den beiden anderen Varianten verwendet diese Komponente die ECHTEN [Bootstrap]-Klassen eines Modals, doch ihre Sichtbarkeit wird von [Vue.js] gesteuert (ein [v-if] auf der Eigenschaft [open]) statt vom JavaScript von [Bootstrap] ([bootstrap.bundle.js, new bootstrap.Modal(...)]) – damit nicht beide unabhängig voneinander dieselbe Information verwalten (ist das Modal geöffnet?), eine häufige Quelle subtiler Fehler. Das Originaldokument (2014) verwendete eine Komponente aus der Bibliothek angular-ui-bootstrap (ein „schlüsselfertiges“ Modal), die bereits nach diesem Prinzip entworfen war.

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

Diese Komponente erfüllt die Rolle, die in der ursprünglichen AngularJS-1.x-Anwendung der „Hauptcontroller“ spielte, sowie die der App-Komponenten auf der [Angular] und [React] -Seite: 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 „Türstehers“ auf der Präsentationsschicht, der entscheidet, ob der Anmeldebildschirm oder der Rest der Anwendung angezeigt wird. Eine [Vue.js]-Komponente vereint in einer einzigen [.vue]-Datei, was [Angular] auf drei Dateien aufteilt (app.ts, app.html, app.css) – genau wie es App.tsx bereits bei [React]tat.

6.11.1. src/app/App.vue

<script setup lang="ts">
import { ref, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useAuth } from './core/composables/auth.composable';
import { useSettings } from './core/composables/settings.composable';
import { useLanguage } from './core/composables/language.composable';
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.vue';
import Schedule from './features/schedule/Schedule.vue';
import BookingDialog from './features/booking-dialog/BookingDialog.vue';
import Login from './features/login/Login.vue';

const { t } = useI18n();
const auth = useAuth();
const settings = useSettings();
const language = useLanguage();
const api = useAppointmentService();

const doctors = ref<Doctor[]>([]);
const clients = ref<Client[]>([]);
const schedule = ref<DoctorDaySchedule | null>(null);
const error = ref<string | null>(null);
const slotBeingBooked = ref<SlotJson | null>(null);
const lastDoctorId = ref<number | null>(null);
const lastDay = ref<string | null>(null);

watch(
  () => auth.isLoggedIn,
  (isLoggedIn) => {
    if (isLoggedIn) {
      loadInitialLists();
    }
  },
  { immediate: true },
);

function loadInitialLists(): void {
  api
    .getAllDoctors()
    .then((result) => (doctors.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));

  api
    .getAllClients()
    .then((result) => (clients.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}

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

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

function onBookingRequest(slot: SlotJson): void {
  slotBeingBooked.value = slot;
}

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

function onCloseBooking(): void {
  slotBeingBooked.value = null;
}

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

function loadSchedule(): void {
  if (lastDoctorId.value === null || lastDay.value === null) {
    return;
  }
  api
    .getDoctorScheduleOfDay(lastDoctorId.value, lastDay.value)
    .then((result) => (schedule.value = result))
    .catch((err: unknown) => (error.value = String((err as Error).message ?? err)));
}
</script>

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

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

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

    <div class="row g-2 align-items-center mb-4">
      <div class="col-auto">
        <label class="form-label mb-0" for="input-server-url">
          {{ t('APP.SERVER_URL_LABEL') }}
        </label>
      </div>
      <div class="col-sm-4">
        <input id="input-server-url" type="text" class="form-control form-control-sm"
          v-model="settings.apiBaseUrl" />
      </div>
    </div>

    <div v-if="error" class="alert alert-danger" role="alert">
      {{ error }}
    </div>

    <Login v-if="!auth.isLoggedIn" />

    <template v-else>
      <DoctorDayPicker :doctors="doctors" @search="onSearchSchedule" />

      <Schedule
        :schedule="schedule"
        :can-edit="auth.isAdmin"
        @book="onBookingRequest"
        @cancel="onCancelAppointment"
      />

      <BookingDialog
        :open="slotBeingBooked !== null"
        :slot="slotBeingBooked"
        :clients="clients"
        @confirm="onConfirmBooking"
        @close="onCloseBooking"
      />
    </template>
  </div>
</template>

Kommentieren wir diesen Code:

  • Zeilen 25–26: [const lastDoctorId = ref<number | null>(null); const lastDay = ref<string | null>(null);] – wir speichern die letzte Suche (Arzt + Tag), um den Terminkalender nach einer Buchung oder Stornierung aktualisieren zu können. Wie bei [React] (ein [useRef](), kein [useState]()) werden diese beiden Werte nie direkt zur Anzeige verwendet (anders als der Terminkalender oder die Fehlerseiten) – aber anders als bei [React] erfordert [Vue.js] keinen speziellen Hook ([useRef]) für eine Variable, die Renderings überdauert, ohne ein erneutes Zeichnen auszulösen: Da ein [<script setup>] nur einmal pro Komponenteninstanz läuft (anders als eine [React]-Komponentenfunktion, die bei jedem Rendering erneut ausgeführt wird), hätte eine einfache JavaScript-Variable (let) genauso gut funktioniert; [ref()] wird hier lediglich der Einheitlichkeit mit dem Rest der Datei halber verwendet;
  • Zeilen 28–36: [watch(() => auth.isLoggedIn, (isLoggedIn) => { if (isLoggedIn) { loadInitialLists(); } }, { immediate: true });] – führt seinen Rumpf jedes Mal erneut aus, wenn sich [auth.isLoggedIn] ändert – das direkte Äquivalent zu [effect(() => { if (this.auth.isLoggedIn()) { … } })] auf der [Angular]-Seite und zu [useEffect](..., [auth.isLoggedIn]) auf der [React]-Seite. [{ immediate: true }] bewirkt außerdem, dass er beim ersten Mal sofort läuft, ohne auf eine Änderung zu warten – genau das Verhalten von [useEffect]() auf der [React]-Seite (der bei der Initialisierung immer mindestens einmal läuft): Wenn bereits eine Sitzung in [localStorage] gespeichert war (Neuladen der Seite), werden die Listen beim Start sofort geladen, ohne auf eine Anmeldung zu warten;
  • Zeilen 112–133: [div class="btn-group btn-group-sm" … FR … EN … template v-if="auth.isLoggedIn" …] – die Sprachauswahl ist IMMER sichtbar (auch auf dem Anmeldebildschirm); das Rollen-Badge samt Name und der Abmelde-Button werden dagegen nur angezeigt, wenn [auth.isLoggedIn] gilt (Zeilen 126–132, [template v-if="auth.isLoggedIn"]) – genau dieselbe Logik wie bei [Angular] und [React];
  • Zeile 152: [Login v-if="!auth.isLoggedIn"] – solange [useAuth().isLoggedIn] false ist, zeigt diese Komponente nur <Login /> an; da alle Server-Routen nun durch [JwtAuthGuard] geschützt sind (Kapitel 3), wäre es ohnehin sinnlos (und würde 401-Fehler verursachen), Ärzte/Kunden/Terminkalender vor der Anmeldung zu laden – genau dieselbe Überlegung wie bei [Angular] und [React];
  • Zeilen 154–171: [template v-else … DoctorDayPicker … Schedule … BookingDialog …] – die drei „fachlichen“ Komponenten aus features/ werden hier zusammengesetzt, jeweils mit ihren Props (Daten, mit dem Präfix [:]) und ihren Ereignis-Handlern (mit dem Präfix [@]) – das exakte Äquivalent zum Template app.html auf der [Angular]-Seite, wo dieselben drei Komponenten mit [doctors]="doctors()" (search)="onSearchSchedule($event)" … erschienen.

Zustand ([ref]), Effekt ([watch]) und Ereignis-Handler (die onXxx-Funktionen): Das sind genau dieselben Bausteine, die bereits im vorigen Kapitel 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 aufgenommen wie bei den Varianten [Angular] und [React] dieses Kurses, hier mit diesem [Vue.js]-Client: Server-URL auf ihrem Standardwert (http://localhost:8080), Demo-Konten admin/admin und user/user.

6.12.1. 1. Anmeldebildschirm

Beim ersten Laden der Seite ist [useAuth().isLoggedIn] auf false gesetzt (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.vue gespeicherte Fehlermeldung an:

Image

Anmeldefehler

Die weiterhin sichtbare FR/EN-Auswahl übersetzt auch diesen Bildschirm (und die gespeicherte Fehlermeldung, die ohne zusätzlichen Code neu übersetzt wird; siehe Login.vue oben):

Image

Anmeldebildschirm auf Französisch

6.12.2. 2. Als Administrator anmelden (Rolle ADMIN, Vollzugriff)

Nach der Anmeldung mit admin/admin zeigt App.vue <Login /> nicht mehr an und lädt Ärzte/Kunden ([loadInitialLists()], ausgelöst durch [watch(() => auth.isLoggedIn, …, { immediate: true })] in Zeile 28):

Image

Startseite nach der Anmeldung als ADMIN

Image

Startseite nach der Anmeldung als ADMIN, auf Französisch

Nachdem Sie in <DoctorDayPicker /> einen Arzt und ein Datum ausgewählt haben, wird der Terminkalender mit den Buttons „Book“/„Cancel“ angezeigt (canEdit ist für die Rolle ADMIN auf true gesetzt):

Image

Terminkalender, ADMIN-Ansicht (Buttons „Book“/„Cancel“ sichtbar)

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

Image

Buchungsfenster (Bootstrap-Modal)

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

Image

Terminkalender nach der Buchung

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

Image

Terminkalender nach der Stornierung

6.12.3. 3. Als Benutzer anmelden (Rolle USER, nur lesend)

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

Image

Startseite nach der Anmeldung als USER

Der Terminkalender bleibt einsehbar, aber es erscheinen keine Buttons „Book“/„Cancel“: Die Aktionsspalte ist für jedes Zeitfenster leer (siehe Schedule.vue, [v-if="canEdit"] am Button). Eine direkte Anfrage an den Server (zum Beispiel mit Postman und unter Angabe des Tokens des Benutzers) würde weiterhin eine Antwort 403 Forbidden erhalten – das Ausblenden des Buttons ist lediglich eine Anzeigekomfortfunktion; die eigentliche Einschränkung wird serverseitig durch [RolesGuard] durchgesetzt (Kapitel 3):

Image

Terminkalender, USER-Ansicht (nur lesend, keine Aktions-Buttons)

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

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 den Varianten [Angular] und [React] dieses Kurses – er wird auch in einer späteren Etappe des Kurses nicht auftauchen (die Begründung für diese Entscheidung finden Sie in Kapitel 6, Fazit). Die Konfiguration einer künstlichen Netzwerkverzögerung hingegen ist in allen drei Varianten tatsächlich auf eine spätere Etappe verschoben.

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

  • Unit-Tests (die in diesem Projekt ebenso fehlen wie in den Projekten [Angular] und [React] dieses Kurses) würden in [Vue.js] einen anderen Ansatz verfolgen: Statt TestBed (spezifisch für [Angular]) oder [React Testing Library] ([React]) stützt sich das [Vue.js]-Ökosystem typischerweise auf [Vue Test Utils] – in diesem Dokument nicht vorgestellt;
  • die Typprüfung des [<template>] hat hier einen besonderen Status: Anders als bei [React] (wo der Standard-TypeScript-Compiler genügt, da [JSX] nur eine weitere Ausprägung von JavaScript ist) stellt [Vue.js] [vue-tsc] (siehe package.json, Kapitel 5) genau FÜR diesen Zweck bereit, das die Typen innerhalb des [<template>] prüft – eine Situation, die in diesem speziellen Punkt näher an [Angular] und strictTemplates liegt als an [React], auch wenn es sich um ein eigenständiges Werkzeug und nicht um eine Option des Compilers selbst handelt.