10. Fallstudie: Der Vue.js-Client für die Anwendung RdvMedecins
10.1. Die Aufgabenstellung
Die Anwendung [RdvMedecins] ermöglicht es, Termine in einer Arztpraxis zu vereinbaren. Im [NestJS]-Kurs wurde sie als HTML-Anwendung geschrieben, in der der Server die Seiten erzeugte. Hier schreiben wir den Client [Vue.js]: dieselben Seiten, im Browser erzeugt aus den JSON-Daten des Servers, die im Kapitel „Der RdvMedecins-Server: eine Blackbox“ beschrieben sind.
Der Client muss alles bieten, was die HTML-Anwendung bot:
- eine durch ein CAPTCHA geschützte Anmeldeseite mit der Möglichkeit, ein Patientenkonto zu erstellen;
- der Terminkalender eines Arztes für einen bestimmten Tag, mit Terminbuchung (Fenster zur Patientenauswahl) und Stornierung;
- für den Administrator die Verwaltung von Ärzten und Clients (Liste, Hinzufügen, Bearbeiten, Löschen);
- für den Patienten ein persönliches Dashboard (mit bevorstehenden Terminen, die er stornieren kann) und die Kontoverwaltung;
- zwei Sprachen: Französisch und Englisch;
- eindeutige URLs ([/schedule?doctorId=1&day=...]), die neu geladen, als Lesezeichen gespeichert und mit den Vor-/Zurück-Schaltflächen des Browsers durchlaufen werden können.
10.2. Installation und Ausführung
Der JSON-Server muss installiert sein und laufen (siehe vorheriges Kapitel). Um den Client in einem Browser zu verwenden, brauchen Sie den CAPTCHA-Testmodus nicht: Sie dürfen ihn NICHT in der Datei [.env] des Servers setzen.
In einem Konsolenfenster, geöffnet im Ordner [rdvmedecins-vuejs]:
Öffnen Sie dann http://localhost:5173 in einem Browser. Die Demokonten sind auf der Anmeldeseite aufgeführt (Passwort = Login).
Der [Vite]-Server der Beispiele verwendet ebenfalls Port 5173. Ist dieser Port bereits belegt, [Vite] wählt einen anderen (5174 ...) und zeigt ihn in der Konsole an: Sie müssen dann diese Adresse öffnen.
10.3. Die Anwendung verwenden
10.3.1. Die Anmeldeseite

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

10.3.2. Der Terminkalender, wie ihn Administrator und Ärzte sehen
Als [admin] angemeldet, gelangen Sie zum Terminkalender:

Wählen Sie einen Arzt und einen Tag und klicken Sie dann auf „Terminkalender anzeigen“. Die URL wird zu [/schedule?doctorId=1&day=2026-09-28]:

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

Der Termin ist gespeichert:

„Stornieren“ fordert zur Bestätigung auf:

Ein Arzt gelangt direkt zu SEINEM EIGENEN Tagesterminkalender:

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

Im Terminkalender sieht er bei den Zeitfenstern anderer Patienten „Belegt“:

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

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

Sein Dashboard zeigt Folgendes:

„Mein Konto verwalten“: Jede Änderung erfordert das aktuelle Passwort; die Fehler kommen vom Server:

Gibt er die Adresse [/doctors] ein, die dem Administrator vorbehalten ist:

10.3.4. Ärzte und Clients verwalten

Ein falsch ausgefüllter Eintrag:

Eine erfolgreiche Hinzufügung:

Ein Namensvetter:

Die Anfrage, einen Arzt mit bevorstehenden Terminen zu entfernen, wird abgelehnt:

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

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

10.3.6. Auf Französisch
Die Schaltflächen FR / EN übersetzen die Seite sofort, ohne Anfragen an den Server zu senden:

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

Eine unbekannte Adresse:

10.4. Client-Architektur

| rdvmedecins-vuejs/
├── index.html THE page of the application
├── public/favicon.svg the tab icon
├── package.json, vite.config.ts, tsconfig.json, env.d.ts
└── src/
├── main.ts the startup
├── App.vue the layout shared by all the pages
├── styles.css
├── router.ts the pages and their access rights
├── i18n.ts the languages
├── locales/ fr.json, en.json
├── api/ the API access layer
├── stores/ session.ts, messages.ts
├── composables/ useConfirmation, useFormatting, useForm
├── components/ the reusable components
└── views/ the pages
|
Die folgende Tabelle vergleicht die HTML-Anwendung aus dem [NestJS]-Kurs mit diesem Client:
HTML-Anwendung (NestJS) | Vue.js-Client |
Der Server erzeugt jede Seite ([res.render]) | Der Server liefert JSON; die Komponenten in [src/views/] erzeugen die Seiten |
[views/layout.hbs] und seine Partial Views | [App.vue] und die Komponenten in [src/components/] |
die Routen der Controller ([@Controller('schedule')]) | Client-Routen ([router.ts]); der Server hat nur Routen [/api/...] |
[JwtAuthGuard] und [RolesGuard] leiten um zu [/login] oder zu einer 403-Seite | der Guard des Routers; der Server unterhält eigene Guards, die mit 401 / 403 antworten |
Flash-Meldung in einem Cookie | Flash-Meldung in einem Pinia-Store |
vom Server gelesene Wörterbücher, Helper [{{t}}] | Wörterbücher auf dem Client, [vue-i18n]; der Server liefert nur Schlüssel |
Sprache in einem Cookie gespeichert | Sprache gespeichert in [localStorage] |
Formular abgelehnt: Der Server lädt die Seite neu | Formular abgelehnt: 400/409-Antwort; der Client zeigt die Fehler an |
Bestätigungsfenster: ein kleines Skript, [public/js/app.js] | eine Komponente, [ConfirmDialog.vue] |
Die Anwendung funktioniert ohne JavaScript | Die Anwendung IST JavaScript |
10.5. Projektkonfiguration
10.5.1. package.json
| {
"name": "rdvmedecins-vuejs",
"version": "1.0.0",
"description": "Vue.js client of the medical appointment booking application [RdvMedecins] - client of the JSON server [rdvmedecins-nestjs-json]",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vue-tsc --noEmit && vite build",
"preview": "vite preview",
"check": "vue-tsc --noEmit"
},
"dependencies": {
"bootstrap": "^5.3.8",
"pinia": "^3.0.4",
"vue": "^3.5.22",
"vue-i18n": "~11.3.2",
"vue-router": "^4.6.3"
},
"devDependencies": {
"@types/node": "^22.10.0",
"@vitejs/plugin-vue": "^6.0.1",
"@vue/tsconfig": "^0.8.1",
"typescript": "~5.9.3",
"vite": "^7.1.12",
"vue-tsc": "^3.1.3"
}
}
|
Dieselben Bibliotheken wie in den Beispielen. Ein zusätzlicher Befehl:
- Zeile 10: [npm run preview] stellt die kompilierte Version der Anwendung bereit (Ordner [dist/], erzeugt von [npm run build]), um sie vor der Bereitstellung zu überprüfen.
10.5.2. vite.config.ts
| // =========================================================================
// vite.config.ts
// -------------------------------------------------------------------------
// - npm run dev : Entwicklungsserver auf http://localhost:5173;
// die Anfragen an /api/... werden vom Proxy an den JSON-Server
// (Port 8080) weitergeleitet: Seite und API haben denselben
// Ursprung, das Token-Cookie wird ganz normal übertragen;
// - npm run build : die kompilierte Anwendung in dist/. Für die Produktion
// kopieren Sie den INHALT von dist/ in den
// Ordner client/ des JSON-Servers, der sie dann selbst ausliefert
// (siehe Kapitel "Bereitstellung").
// =========================================================================
import { defineConfig } from 'vite';
import vue from '@vitejs/plugin-vue';
export default defineConfig({
plugins: [vue()],
server: {
port: 5173,
proxy: {
'/api': 'http://localhost:8080',
},
},
// npm run preview: liefert dist/ aus (nach npm run build), mit demselben Proxy
preview: {
port: 4173,
proxy: {
'/api': 'http://localhost:8080',
},
},
});
|
- Zeilen 21–23: der Proxy für Anfragen von [/api] an den JSON-Server;
- Zeilen 26–31: derselbe Proxy für [npm run preview].
Ein wichtiges Detail: Die Anwendung verwendet „saubere“ Adressen ([/schedule], [/my-area]). Wenn Sie die Seite [/schedule] neu laden, fordert der Browser [/schedule] vom [Vite]-Server an. Da der Server keine Datei mit diesem Namen findet, liefert er [index.html] (das ist sein Standardverhalten für eine Single-Page-Anwendung); die Anwendung startet, und ihr Router zeigt die Terminkalenderseite an.
10.5.3. tsconfig.json und env.d.ts
Identisch mit denen der Beispiele, abgesehen von der Dateiliste:
| {
"extends": "@vue/tsconfig/tsconfig.dom.json",
"compilerOptions": {
"types": ["vite/client"],
"noUnusedLocals": true,
"noUnusedParameters": true
},
"include": ["src/**/*.ts", "src/**/*.vue", "env.d.ts"]
}
|
10.6. Start der Anwendung
10.6.1. index.html
| <!doctype html>
<!--
index.html - THE page of the application (Single Page Application).
The server never sends any other: everything else is built in
the browser by Vue.js, in <div id="app">. lang and title are
updated by the application according to the language and the page displayed.
-->
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="/favicon.svg" type="image/svg+xml">
<title>RdvMedecins</title>
</head>
<body>
<div id="app"></div>
<!-- ohne JavaScript kann eine Vue.js-Anwendung nichts anzeigen: Wir weisen darauf hin -->
<noscript>RdvMedecins requires JavaScript. / RdvMedecins a besoin de JavaScript.</noscript>
<script type="module" src="/src/main.ts"></script>
</body>
</html>
|
- Zeile 12: das Tab-Symbol. Die Dateien im Ordner [public/] werden unverändert im Stammverzeichnis der Website ausgeliefert;
- Zeile 18: Ohne [JavaScript] kann eine [Vue.js]-Anwendung nichts anzeigen. Die HTML-Anwendung aus dem [NestJS]-Kurs funktionierte dagegen ohne [JavaScript]: Das ist der Kompromiss einer Single-Page-Anwendung;
- Zeile 19: das Programm.
10.6.2. src/main.ts
| // =========================================================================
// main.ts - der Start der Anwendung
// -------------------------------------------------------------------------
// 1. Bootstrap (CSS) und unsere wenigen Stile;
// 2. Pinia (Stores), vue-i18n (Sprachen), der Router;
// 3. die Reaktion auf eine 401-Antwort aus einer beliebigen Anfrage:
// Die Sitzung ist abgelaufen - wir vergessen den Benutzer und gehen zurück zur
// Login-Seite, mit einer Meldung;
// 4. die Anzeige in <div id="app">.
// =========================================================================
import { createApp } from 'vue';
import { createPinia } from 'pinia';
import 'bootstrap/dist/css/bootstrap.min.css';
import './styles.css';
import App from './App.vue';
import { i18n } from './i18n';
import { router } from './router';
import { whenUnauthenticated } from './api/http-client';
import { useSessionStore } from './stores/session';
import { useMessagesStore } from './stores/messages';
const app = createApp(App);
app.use(createPinia());
app.use(i18n);
app.use(router);
whenUnauthenticated(() => {
useSessionStore().forget();
useMessagesStore().flash('error', 'ERRORS.SESSION_EXPIRED');
router.push({ name: 'login' });
});
app.mount('#app');
|
- Zeilen 24–26: die drei Erweiterungen: Stores, Sprachen und der Router. [Pinia] muss VOR dem Router installiert werden: Der Guard des Routers verwendet einen Store;
- Zeilen 28–32: Was zu tun ist, wenn irgendeine Anfrage eine 401-Antwort erhält (Sitzung abgelaufen, Konto gelöscht usw.): den Benutzer vergessen, die Meldung „Ihre Sitzung ist abgelaufen“ für die nächste Seite vorbereiten und zur Anmeldeseite umleiten. Diese Reaktion wird EINMAL hier deklariert; die Funktion [whenUnauthenticated] wird bei [http-client.ts] beschrieben.
10.6.3. src/App.vue
| <!--
=========================================================================
App.vue - the root component: the TEMPLATE common to all the pages
-------------------------------------------------------------------------
The equivalent of views/layout.hbs of the HTML application:
- the navigation bar;
- a success message at the TOP;
- the current page (<RouterView>);
- the error panel at the BOTTOM;
- the confirmation dialog, once for the whole application.
:key="String(route.name)" on <RouterView>: when going from one route to
ANOTHER (from /doctors to /clients, for example), the page component
is recreated; when only the query changes (/schedule?day=...), it is
kept, and it is the component that follows the URL.
=========================================================================
-->
<script setup lang="ts">
import { RouterView, useRoute } from 'vue-router';
import NavBar from './components/NavBar.vue';
import SuccessMessage from './components/SuccessMessage.vue';
import ErrorPanel from './components/ErrorPanel.vue';
import ConfirmDialog from './components/ConfirmDialog.vue';
const route = useRoute();
</script>
<template>
<div class="container py-4">
<NavBar />
<SuccessMessage />
<RouterView :key="String(route.name)" />
<ErrorPanel />
</div>
<ConfirmDialog />
</template>
|
Das allen Seiten gemeinsame Template, gleichbedeutend mit [views/layout.hbs]:
- Zeile 30: die Navigationsleiste;
- Zeile 31: eine Erfolgsmeldung am oberen Rand;
- Zeile 32: die aktuelle Seite. Das Attribut [:key]: Ändert sich der Schlüssel einer Komponente, [Vue.js] zerstört es sie und erstellt eine neue. Mit dem Routen-NAMEN als Schlüssel erzeugt der Wechsel von [/doctors] zu [/clients] (zwei verschiedene Routen, von derselben Komponente angezeigt) die Seite neu, die dann ihre Daten neu lädt. Ändert sich nur die [query] (auf [/schedule?day=...]), bleibt die Seite erhalten, und sie ist es, die ihrer URL folgt;
- Zeile 33: der Fehlerbereich am unteren Rand;
- Zeile 35: das Bestätigungsfenster, einmal für die gesamte Anwendung angezeigt.
10.6.4. src/styles.css
| /* =========================================================================
styles.css - einige Einstellungen zusätzlich zu Bootstrap
(übernommen aus public/css/styles.css der HTML-Anwendung)
========================================================================= */
body {
background-color: #f5f7fa;
}
.free-slot:hover {
background-color: #e9f7ef;
}
/* -------------------------------------------------------------------------
.error-panel: die Fehlermeldungen am unteren Seitenrand auf hellrosa
Hintergrund (siehe components/ErrorPanel.vue).
position: sticky + bottom: Wenn die Seite höher als das Fenster ist, bleibt das
Panel am unteren Fensterrand haften, statt unterhalb des sichtbaren
Bereichs zu verschwinden - ohne jemals den Inhalt zu verdecken, wenn die Seite
kurz ist. z-index: über dem grauen Hintergrund der modalen Dialoge.
pointer-events: none: Das Panel enthält nichts Anklickbares; wenn es
eine Schaltfläche überlappt, geht der Klick hindurch.
------------------------------------------------------------------------- */
.error-panel {
position: sticky;
bottom: 1rem;
z-index: 1060;
pointer-events: none;
margin-top: 1.5rem;
padding: 0.75rem 1rem;
background-color: #fdecef; /* helles Rosa */
border: 1px solid #f5c2c7;
border-radius: 0.375rem;
color: #842029;
}
/* die beiden Hauptoptionen der Seite "Mein Bereich" des Patienten */
.option-card {
transition: border-color 0.15s, box-shadow 0.15s;
}
.option-card:hover {
border-color: #0d6efd;
box-shadow: 0 0.25rem 0.75rem rgba(13, 110, 253, 0.15);
}
/* das CAPTCHA-Bild (SVG mit 150 x 50 Pixeln) */
.captcha-image svg {
display: block;
border: 1px solid #dee2e6;
border-radius: 0.375rem;
}
|
Die Stile der HTML-Anwendung, mit einer Ergänzung:
- Zeile 28: Der Fehlerbereich, der am unteren Fensterrand „klebt“, kann eine Schaltfläche überdecken (etwa ein Bestätigungsfenster in der Mitte einer kurzen Seite); er enthält nichts Anklickbares, und ein Klick geht einfach hindurch.
10.7. Die Zugriffsschicht der API
10.7.1. src/api/types.ts
Die JSON-Objekte der API, im Kapitel über die Blackbox beschrieben, übersetzt in [TypeScript]-Interfaces:
| // =========================================================================
// api/types.ts - die mit dem Server ausgetauschten JSON-Objekte
// -------------------------------------------------------------------------
// Die Übersetzung der im Kapitel "Der Server, eine Blackbox" beschriebenen API
// in TypeScript-Interfaces. Der Compiler prüft so, dass der Client
// nur Felder verwendet, die wirklich existieren.
// =========================================================================
export type Role = 'ADMIN' | 'DOCTOR' | 'USER';
// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
export interface User {
login: string;
name: string; // Anzeigename: "Marie PELISSIER"
role: Role;
}
// GET /api/captcha
export interface Captcha {
id: string;
svg: string;
}
// eine Anrede, ein Vorname, ein Nachname
export interface Identity {
title: string;
firstName: string;
lastName: string;
}
// ein Arzt oder ein Client: GET /api/doctors, GET /api/clients/:id ...
export interface Person extends Identity {
id: number;
version: number; // optimistisches Sperren: bei einer Aktualisierung mitzusenden
login?: string; // nur für den ADMIN
}
// das, was zum Anlegen / Aktualisieren einer Person gesendet wird (ADMIN)
export interface PersonData extends Identity {
login: string; // '' = Standardwert (Anlegen) oder unverändert (Aktualisieren)
password: string; // dasselbe
version?: number;
}
export interface Slot {
id: number;
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
// eine Zeile des Terminkalenders, mit den RECHTEN des angemeldeten Benutzers
export interface ScheduleSlot extends Slot {
free: boolean;
patient: Identity | null; // null: frei oder von einem anderen Patienten belegt
mine: boolean; // der Termin des angemeldeten Patienten
bookable: boolean;
appointmentId: number | null; // ausgefüllt, wenn der Benutzer stornieren kann
}
// GET /api/schedule?doctorId=...&day=...
export interface Schedule {
doctor: Person;
day: string; // "yyyy-MM-dd"
slots: ScheduleSlot[];
info: string | null; // Übersetzungsschlüssel (Patient, der bereits einen Termin hat)
}
// GET /api/my-area
export interface MyArea {
patient: Identity;
appointments: { id: number; day: string; slot: Slot; doctor: Person }[];
}
// GET /api/my-account
export interface MyAccount extends Identity {
login: string;
version: number;
}
// PUT /api/my-account
export interface MyAccountUpdate extends Identity {
login: string;
password: string; // '' = unverändert
confirmation: string;
currentPassword: string;
version: number;
}
// POST /api/register
export interface Registration extends Identity {
login: string;
password: string;
confirmation: string;
}
|
- Zeile 32: Ein Interface kann ein anderes erweitern: Eine [Person] ist eine [Identity] , die zusätzlich eine ID, eine Version und, für ADMIN, ein Login hat;
- Zeile 54: ein Eintrag im Terminkalender: ein Zeitfenster plus die Berechtigungen des angemeldeten Benutzers;
- Zeilen 39 ff.: was der Client an den Server SENDET.
10.7.2. src/api/http-client.ts
Die Funktion [request] aus Beispiel 19 ([common/api.ts]) mit zentralisierter Behandlung der 401-Antwort:
| // =========================================================================
// api/http-client.ts - die Funktion, die ALLE Anfragen an die API sendet
// -------------------------------------------------------------------------
// Übernommen aus common/api.ts der Beispiele, mit einer Neuerung: der
// zentralen Behandlung der 401-Antwort.
//
// Ein 401 kann jederzeit auftreten: Das Token ist abgelaufen (2 Stunden), das
// Konto wurde gelöscht, der Server wurde mit einem anderen geheimen
// Schlüssel neu gestartet ... Statt diesen Fall in jeder Komponente zu behandeln,
// benachrichtigen wir EINE beim Start registrierte Funktion (siehe main.ts), die
// den Benutzer vergisst und zur Login-Seite zurückleitet.
// =========================================================================
export class ApiError extends Error {
constructor(
public readonly statusCode: number, // 0: Der Server hat nicht geantwortet
public readonly key: string, // Übersetzungsschlüssel: 'ERRORS.LOGIN_TAKEN'
public readonly params: Record<string, string> = {},
public readonly fields: Record<string, string> = {}, // Fehler jedes Feldes
) {
super(key);
this.name = 'ApiError';
}
}
// die bei jeder 401-Antwort aufgerufene Funktion (siehe main.ts)
let onUnauthenticated: (error: ApiError) => void = () => {};
export function whenUnauthenticated(callback: (error: ApiError) => void): void {
onUnauthenticated = callback;
}
type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
export interface RequestOptions {
// die öffentlichen Routen (Login, CAPTCHA ...) und GET /api/auth/me
// behandeln den 401 selbst: keine automatische Weiterleitung
ignore401?: boolean;
}
export async function request<T>(method: Method, url: string, body?: unknown, options: RequestOptions = {}): Promise<T> {
let response: Response;
try {
response = await fetch(`/api${url}`, {
method,
headers: body !== undefined ? { 'Content-Type': 'application/json', Accept: 'application/json' } : { Accept: 'application/json' },
body: body !== undefined ? JSON.stringify(body) : undefined,
});
} catch {
throw new ApiError(0, 'ERRORS.SERVER_UNREACHABLE');
}
// als Text gelesen und dann konvertiert: Eine leere Antwort oder eine, die kein
// JSON ist (Server gestoppt: Es antwortet der Vite-Proxy), bringt die Anwendung nicht
// zum Absturz
const text = await response.text();
let data: unknown = null;
try {
data = text ? JSON.parse(text) : null;
} catch {
data = null;
}
if (response.ok) {
return data as T;
}
const e = (data ?? {}) as { key?: string; params?: Record<string, string>; fields?: Record<string, string> };
const error = new ApiError(
response.status,
// kein Schlüssel: Es hat nicht unser Server geantwortet, sondern ein Proxy
// (Vite: 500 ohne Body; nginx: 502, 504 ...)
e.key ?? (response.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR'),
e.params,
e.fields,
);
if (response.status === 401 && !options.ignore401) {
onUnauthenticated(error);
}
throw error;
}
|
- Zeilen 14–23: ein Anfragefehler: HTTP-Code, Meldungsschlüssel, Parameter, Fehler für jedes Feld;
- Zeile 27: die Funktion, die bei jeder 401-Antwort aufgerufen wird. Anfangs tut sie nichts; [main.ts] liefert eine über [whenUnauthenticated]. Warum rufen wir den Router nicht direkt hier auf? Weil die Zugriffsschicht der API nichts über die Seiten wissen soll: Sie meldet den Fehler, und die Anwendung entscheidet;
- Zeilen 35–39: Manche Anfragen erwarten eine 401 und behandeln sie selbst: ein falsches Passwort ([POST /api/auth/login] antwortet mit 401) oder die Frage „Wer ist angemeldet?“ ([GET /api/auth/me], 401, wenn niemand angemeldet ist). Für diese gibt es keine automatische Umleitung;
- Zeile 46: Der Header [Accept] teilt dem Server das gewünschte Antwortformat mit;
- Zeile 50: überhaupt keine Antwort;
- Zeile 73: Eine Antwort ohne Schlüssel stammt nicht von unserem Server: Wenn der JSON-Server nicht läuft, antwortet der Proxy (der von [Vite] liefert einen 500-Fehler ohne Body; ein Produktions-Proxy wie [nginx] liefert 502 oder 504);
- Zeilen 77–79: eine unerwartete 401: Wir benachrichtigen die Anwendung und lehnen dann das Promise ab, wie bei jedem Fehler.
10.7.3. src/api/rdvmedecins.api.ts
Eine Funktion pro API-Route:
| // =========================================================================
// api/rdvmedecins.api.ts - eine Funktion pro Route der API
// -------------------------------------------------------------------------
// Die "Datenzugriffsschicht" des Clients: Die Komponenten rufen diese
// typisierten Funktionen auf, ohne etwas über URLs, fetch oder JSON zu wissen. Ändert sich die API,
// ändert sich nur diese Datei.
// =========================================================================
import { request } from './http-client';
import type {
Schedule,
Captcha,
PersonData,
Registration,
MyAccountUpdate,
MyAccount,
MyArea,
Person,
User,
} from './types';
// /api/doctors oder /api/clients: beide werden auf dieselbe Weise verwaltet
export type PersonType = 'doctors' | 'clients';
type Empty = Record<string, never>;
export const rdvApi = {
// Login (öffentliche Routen)
captcha: () => request<Captcha>('GET', '/captcha', undefined, { ignore401: true }),
me: () => request<User>('GET', '/auth/me', undefined, { ignore401: true }),
logIn: (login: string, password: string, captchaId: string, captcha: string) =>
request<User>('POST', '/auth/login', { login, password, captchaId, captcha }, { ignore401: true }),
logOut: () => request<Empty>('POST', '/auth/logout', {}, { ignore401: true }),
// Kontoerstellung (öffentlich)
registrationAccess: (captchaId: string, captcha: string) =>
request<Empty>('POST', '/register/access', { captchaId, captcha }, { ignore401: true }),
registrationAccessStatus: () => request<{ valid: boolean }>('GET', '/register/access', undefined, { ignore401: true }),
register: (data: Registration) => request<{ login: string }>('POST', '/register', data, { ignore401: true }),
// Terminkalender und Termine
// doctorId null: bei einem angemeldeten Arzt SEIN Terminkalender
schedule: (doctorId: number | null, day: string) => {
const params = new URLSearchParams({ day });
if (doctorId !== null) {
params.set('doctorId', String(doctorId));
}
return request<Schedule>('GET', `/schedule?${params}`);
},
book: (day: string, slotId: number, clientId: number | null) =>
request<{ id: number }>('POST', '/appointments', { day, slotId, clientId: clientId ?? undefined }),
cancelAppointment: (appointmentId: number) => request<Empty>('DELETE', `/appointments/${appointmentId}`),
// Ärzte und Clients
list: (type: PersonType) => request<Person[]>('GET', `/${type}`),
read: (type: PersonType, id: number) => request<Person>('GET', `/${type}/${id}`),
add: (type: PersonType, data: PersonData) => request<Person>('POST', `/${type}`, data),
edit: (type: PersonType, id: number, data: PersonData) =>
request<Person>('PUT', `/${type}/${id}`, data),
remove: (type: PersonType, id: number) => request<Empty>('DELETE', `/${type}/${id}`),
// der Bereich des Patienten
myArea: () => request<MyArea>('GET', '/my-area'),
myAccount: () => request<MyAccount>('GET', '/my-account'),
editMyAccount: (data: MyAccountUpdate) => request<User>('PUT', '/my-account', data),
deleteMyAccount: (currentPassword: string) => request<Empty>('DELETE', '/my-account', { currentPassword }),
};
|
- Zeile 23: Ärzte und Clients werden gleich behandelt; nur die Adresse ändert sich: [/api/doctors] oder [/api/clients];
- Zeile 25: der Typ eines leeren Objekts, [{}];
- Zeilen 29–33: die Anmelderouten, die ihre 401 selbst behandeln ([ignore401]);
- Zeilen 43–49: Ist kein Arzt verfügbar, wird der Parameter [doctorId] weggelassen; ist ein Arzt verfügbar, liefert der Server SEINEN Terminkalender;
- Zeilen 50–51: [clientId ?? undefined]: [null] wird zu [undefined], und [JSON.stringify] lässt Eigenschaften mit [undefined] weg: Ein Patient sendet kein [clientId];
- Zeilen 55–60: die fünf Operationen auf Einzelpersonen, durch ihren Typ definiert;
- Zeile 66: Eine DELETE-Anfrage kann ebenfalls einen Body haben.
10.8. Sprachen
10.8.1. src/i18n.ts
| // =========================================================================
// i18n.ts - Französisch und Englisch
// -------------------------------------------------------------------------
// Die Wörterbücher locales/fr.json und locales/en.json sind die des
// NestJS-Kurses (i18n/*.json), ergänzt um einige clientspezifische Schlüssel
// (ERRORS.SERVER_UNREACHABLE ...). Der JSON-Server gibt nur SCHLÜSSEL zurück
// ('ERRORS.LOGIN_TAKEN'): Sie sind dieselben wie die der Wörterbücher.
//
// Die gewählte Sprache wird in localStorage gespeichert (eine Einstellung, keine
// sensiblen Daten); andernfalls wird die Sprache des Browsers verwendet.
// =========================================================================
import { createI18n } from 'vue-i18n';
import fr from './locales/fr.json';
import en from './locales/en.json';
export type Language = 'fr' | 'en';
export const LANGUAGES: Language[] = ['fr', 'en'];
const STORAGE_KEY = 'rdvmedecins.language';
function initialLanguage(): Language {
try {
const stored = localStorage.getItem(STORAGE_KEY);
if (stored === 'fr' || stored === 'en') {
return stored;
}
} catch {
// localStorage nicht verfügbar (striktes privates Surfen ...): egal
}
return navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en';
}
export const i18n = createI18n({
legacy: false,
locale: initialLanguage(),
fallbackLocale: 'en',
messages: { fr, en },
// keine Warnung in der Konsole für einen per Fallback übersetzten Schlüssel
fallbackWarn: false,
missingWarn: false,
});
// Sprache wechseln: Die gesamte Anwendung wird auf einmal neu übersetzt
export function changeLanguage(language: Language): void {
i18n.global.locale.value = language;
document.documentElement.lang = language;
try {
localStorage.setItem(STORAGE_KEY, language);
} catch {
// ohne Bedeutung
}
}
document.documentElement.lang = i18n.global.locale.value;
|
- Zeilen 21–31: die gespeicherte Sprache, andernfalls die Sprache des Browsers. Der Zugriff auf [localStorage] ist durch [try / catch] geschützt: Manche Browser blockieren ihn im Inkognito-Modus;
- Zeilen 39–40: keine Warnung in der Konsole, wenn ein Schlüssel fehlt oder aus dem Fallback-Wörterbuch stammt;
- Zeilen 44–52: Sprache wechseln: [i18n.global.locale] ist die Sprache der gesamten Anwendung; auch das Attribut [lang] der Seite wird aktualisiert, und die Auswahl wird gespeichert.
10.8.2. Die Wörterbücher
Dies sind die Schlüssel aus dem Kurs [NestJS], ergänzt um einige clientspezifische Schlüssel ([APP.LOADING], [ERRORS.AUTH_REQUIRED], [ERRORS.JSON_REQUIRED], [ERRORS.SERVER_UNREACHABLE]). Die Fehlercodes sind die vom Server zurückgegebenen.
10.8.2.1. src/locales/fr.json
| {
"APP": {
"TITLE": "RdvMedecins",
"LOGOUT": "Se déconnecter",
"MENU_SCHEDULE": "Agenda",
"MENU_DOCTORS": "Médecins",
"MENU_PATIENTS": "Clients",
"MENU_MY_AREA": "Mon espace",
"LOADING": "Chargement...",
"LANGUAGE": "Langue"
},
"LOGIN": {
"TITLE": "Connexion",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"SUBMIT": "Se connecter",
"ERROR": "Login ou mot de passe incorrect.",
"DEMO_ACCOUNTS": "Comptes de démonstration (mot de passe = login) :",
"DEMO_ADMIN": "rôle ADMIN : rendez-vous + gestion des médecins et des clients",
"DEMO_DOCTOR": "rôle DOCTOR : prise et annulation de rendez-vous",
"DEMO_USER": "rôle USER (patients) : réservation pour eux-mêmes, gestion de leur compte",
"CREATE_ACCOUNT": "Créer un compte client",
"CREATE_ACCOUNT_HELP": "Pour créer un compte, recopiez d'abord les caractères de l'image."
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Médecin",
"CHOOSE_DOCTOR": "-- choisir un médecin --",
"DAY_LABEL": "Jour",
"VIEW_SCHEDULE": "Voir l'agenda"
},
"SCHEDULE": {
"PAGE_TITLE": "Agenda",
"TITLE_PREFIX": "Agenda du",
"COLUMN_SLOT": "Créneau",
"COLUMN_STATUS": "Statut",
"FREE": "Libre",
"BOOK": "Réserver",
"CANCEL_APPOINTMENT": "Annuler",
"CANCEL_CONFIRM": "Annuler ce rendez-vous ?",
"EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda ».",
"NO_SLOTS": "Ce médecin n'a aucun créneau horaire.",
"BOOKED": "Rendez-vous enregistré.",
"CANCELLED": "Rendez-vous annulé.",
"BOOKED_BY_OTHER": "Réservé",
"ALREADY_BOOKED_INFO": "Vous avez déjà un rendez-vous à venir : annulez-le pour en prendre un autre."
},
"BOOKING_DIALOG": {
"TITLE": "Réserver ce créneau",
"CLOSE_ARIA": "Fermer",
"SLOT": "Créneau de {time}",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choisir un patient --",
"CANCEL": "Annuler",
"CONFIRM": "Confirmer"
},
"PERSONS": {
"COLUMN_TITLE": "Titre",
"COLUMN_FIRSTNAME": "Prénom",
"COLUMN_LASTNAME": "Nom",
"COLUMN_LOGIN": "Login",
"EDIT": "Modifier",
"DELETE": "Supprimer",
"SAVE": "Enregistrer",
"BACK": "Retour à la liste",
"TITLE_LABEL": "Titre",
"FIRSTNAME_LABEL": "Prénom",
"LASTNAME_LABEL": "Nom",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"LOGIN_HELP_CREATE": "Facultatif : par défaut, le nom en minuscules.",
"LOGIN_HELP_EDIT": "Laisser vide pour ne pas le changer.",
"PASSWORD_HELP_CREATE": "Facultatif : par défaut, identique au login.",
"PASSWORD_HELP_EDIT": "Laisser vide pour ne pas le changer.",
"ACCOUNT_SECTION": "Compte utilisateur"
},
"DOCTORS": {
"TITLE": "Médecins",
"ADD": "Ajouter un médecin",
"EDIT": "Modifier un médecin",
"EMPTY": "Aucun médecin.",
"DELETE_CONFIRM": "Supprimer ce médecin, ses créneaux horaires et son compte utilisateur ?",
"ADDED": "Le médecin {name} a été ajouté (login : {login}).",
"UPDATED": "Le médecin {name} a été modifié.",
"DELETED": "Le médecin {name} a été supprimé."
},
"CLIENTS": {
"TITLE": "Clients",
"ADD": "Ajouter un client",
"EDIT": "Modifier un client",
"EMPTY": "Aucun client.",
"DELETE_CONFIRM": "Supprimer ce client, son compte utilisateur et tous ses rendez-vous ?",
"ADDED": "Le client {name} a été ajouté (login : {login}).",
"UPDATED": "Le client {name} a été modifié.",
"DELETED": "Le client {name} a été supprimé."
},
"ERROR_PAGE": {
"TITLE": "Erreur",
"BACK": "Retour à l'accueil"
},
"ERRORS": {
"LOGIN_TAKEN": "Ce login est déjà utilisé par un autre compte.",
"DOCTOR_ALREADY_EXISTS": "Un médecin portant ce prénom et ce nom existe déjà.",
"PATIENT_ALREADY_EXISTS": "Un client portant ce prénom et ce nom existe déjà.",
"DOCTOR_HAS_APPOINTMENTS": "Ce médecin a des rendez-vous : annulez-les avant de le supprimer.",
"SLOT_ALREADY_BOOKED": "Ce créneau vient d'être réservé par quelqu'un d'autre.",
"CONCURRENT_UPDATE": "Cette fiche a été modifiée entre-temps par un autre utilisateur. Revenez à la liste et rouvrez-la avant de recommencer.",
"DOCTOR_NOT_FOUND": "Ce médecin n'existe pas (ou plus).",
"PATIENT_NOT_FOUND": "Ce client n'existe pas (ou plus).",
"SLOT_NOT_FOUND": "Ce créneau n'existe pas (ou plus).",
"APPOINTMENT_NOT_FOUND": "Ce rendez-vous n'existe pas (ou plus).",
"INVALID_DATE": "La date demandée n'est pas valide.",
"CHOOSE_PATIENT": "Choisissez un patient.",
"INVALID_FORM": "Le formulaire contient des erreurs.",
"INVALID_TITLE": "Choisissez un titre dans la liste.",
"FIRSTNAME_REQUIRED": "Le prénom est obligatoire.",
"FIRSTNAME_TOO_LONG": "Le prénom ne doit pas dépasser 20 caractères.",
"LASTNAME_REQUIRED": "Le nom est obligatoire.",
"LASTNAME_TOO_LONG": "Le nom ne doit pas dépasser 20 caractères.",
"INVALID_LOGIN": "30 caractères au plus : lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
"PASSWORD_TOO_LONG": "Le mot de passe ne doit pas dépasser 72 caractères.",
"SESSION_EXPIRED": "Votre session a expiré : reconnectez-vous.",
"BAD_REQUEST": "La requête est invalide.",
"FORBIDDEN": "Votre rôle ne vous permet pas d'accéder à cette page.",
"NOT_FOUND": "Cette page n'existe pas.",
"SERVER_ERROR": "Une erreur inattendue s'est produite. Réessayez plus tard.",
"TOO_MANY_ATTEMPTS": "Trop de tentatives infructueuses. Réessayez dans {minutes} minute(s).",
"WRONG_CAPTCHA": "Les caractères recopiés ne correspondent pas à l'image. Une nouvelle image vous est proposée.",
"TOO_MANY_ACCOUNTS": "Trop de comptes ont été créés depuis votre connexion. Réessayez dans {minutes} minute(s).",
"LOGIN_REQUIRED": "Le login est obligatoire.",
"PASSWORD_REQUIRED": "Le mot de passe est obligatoire.",
"PASSWORD_TOO_SHORT": "Le mot de passe doit comporter au moins {min} caractères.",
"CONFIRMATION_REQUIRED": "Confirmez le mot de passe.",
"PASSWORDS_DIFFER": "La confirmation ne correspond pas au mot de passe.",
"CURRENT_PASSWORD_REQUIRED": "Saisissez votre mot de passe actuel.",
"WRONG_CURRENT_PASSWORD": "Mot de passe actuel incorrect.",
"PAST_DATE": "On ne peut pas prendre de rendez-vous à une date passée.",
"PATIENT_HAS_UPCOMING_APPOINTMENT": "Ce patient a déjà un rendez-vous à venir : il faut l'annuler avant d'en prendre un autre.",
"CAPTCHA_BEFORE_ACCOUNT": "Pour créer un compte, recopiez d'abord correctement les caractères de l'image, puis cliquez sur « Créer un compte client ».",
"AUTH_REQUIRED": "Connectez-vous pour accéder à cette page.",
"JSON_REQUIRED": "Requête refusée : le serveur attend du JSON.",
"SERVER_UNREACHABLE": "Le serveur ne répond pas. Réessayez plus tard."
},
"CAPTCHA": {
"LABEL": "Recopiez les caractères de l'image",
"IMAGE_ALT": "Image de vérification anti-robots",
"NEW_IMAGE": "Autre image",
"HELP": "Majuscules ou minuscules, peu importe."
},
"REGISTRATION": {
"TITLE": "Créer un compte client",
"INTRO": "Ce compte vous permettra de prendre vous-même vos rendez-vous.",
"LOGIN_HELP": "Lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
"PASSWORD_HELP": "Au moins {min} caractères.",
"SUBMIT": "Créer mon compte",
"BACK_TO_LOGIN": "Retour à la connexion",
"DONE": "Votre compte a été créé. Vous pouvez vous connecter avec le login {login}."
},
"ACCOUNT": {
"CONFIRMATION_LABEL": "Confirmation du mot de passe"
},
"AREA": {
"TITLE": "Mon espace",
"HELLO": "Bonjour {name}",
"MANAGE_ACCOUNT": "Gérer mon compte",
"MANAGE_ACCOUNT_HELP": "Modifier mes informations, mon mot de passe, ou supprimer mon compte.",
"VIEW_SCHEDULE": "Voir un agenda",
"VIEW_SCHEDULE_HELP": "Consulter l'agenda d'un médecin et réserver un créneau.",
"MY_APPOINTMENT": "Mon rendez-vous",
"SEE_IN_SCHEDULE": "voir dans l'agenda",
"CANCEL_APPOINTMENT": "Annuler ce rendez-vous",
"NO_APPOINTMENT": "Vous n'avez aucun rendez-vous à venir."
},
"MY_ACCOUNT": {
"TITLE": "Gérer mon compte",
"NEW_PASSWORD_LABEL": "Nouveau mot de passe",
"CURRENT_PASSWORD_LABEL": "Mot de passe actuel",
"CURRENT_PASSWORD_HELP": "Obligatoire pour enregistrer une modification.",
"BACK": "Retour à mon espace",
"DELETE_TITLE": "Supprimer mon compte",
"DELETE_HELP": "Votre compte sera définitivement supprimé, ainsi que tous vos rendez-vous.",
"DELETE_CONFIRM": "Supprimer définitivement votre compte ? Votre rendez-vous éventuel sera annulé.",
"DELETE_SUBMIT": "Supprimer mon compte",
"UPDATED": "Votre compte a été modifié.",
"DELETED": "Votre compte a été supprimé."
},
"CONFIRMATION": {
"TITLE": "Confirmation",
"NO": "Non, revenir",
"YES": "Oui, confirmer"
}
}
|
10.8.2.2. src/locales/en.json
| {
"APP": {
"TITLE": "RdvMedecins",
"LOGOUT": "Log out",
"MENU_SCHEDULE": "Schedule",
"MENU_DOCTORS": "Doctors",
"MENU_PATIENTS": "Patients",
"MENU_MY_AREA": "My area",
"LOADING": "Loading...",
"LANGUAGE": "Language"
},
"LOGIN": {
"TITLE": "Login",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Password",
"SUBMIT": "Log in",
"ERROR": "Incorrect login or password.",
"DEMO_ACCOUNTS": "Demo accounts (password = login):",
"DEMO_ADMIN": "ADMIN role: appointments + doctor and patient management",
"DEMO_DOCTOR": "DOCTOR role: booking and cancelling appointments",
"DEMO_USER": "USER role (patients): booking for themselves, managing their account",
"CREATE_ACCOUNT": "Create a patient account",
"CREATE_ACCOUNT_HELP": "To create an account, first type the characters shown in the image."
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Doctor",
"CHOOSE_DOCTOR": "-- choose a doctor --",
"DAY_LABEL": "Day",
"VIEW_SCHEDULE": "View schedule"
},
"SCHEDULE": {
"PAGE_TITLE": "Schedule",
"TITLE_PREFIX": "Schedule for",
"COLUMN_SLOT": "Slot",
"COLUMN_STATUS": "Status",
"FREE": "Free",
"BOOK": "Book",
"CANCEL_APPOINTMENT": "Cancel",
"CANCEL_CONFIRM": "Cancel this appointment?",
"EMPTY_STATE": "Choose a doctor and a day, then click \"View schedule\".",
"NO_SLOTS": "This doctor has no time slots.",
"BOOKED": "Appointment booked.",
"CANCELLED": "Appointment cancelled.",
"BOOKED_BY_OTHER": "Booked",
"ALREADY_BOOKED_INFO": "You already have an upcoming appointment: cancel it to book another one."
},
"BOOKING_DIALOG": {
"TITLE": "Book this slot",
"CLOSE_ARIA": "Close",
"SLOT": "Slot {time}",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choose a patient --",
"CANCEL": "Cancel",
"CONFIRM": "Confirm"
},
"PERSONS": {
"COLUMN_TITLE": "Title",
"COLUMN_FIRSTNAME": "First name",
"COLUMN_LASTNAME": "Last name",
"COLUMN_LOGIN": "Login",
"EDIT": "Edit",
"DELETE": "Delete",
"SAVE": "Save",
"BACK": "Back to the list",
"TITLE_LABEL": "Title",
"FIRSTNAME_LABEL": "First name",
"LASTNAME_LABEL": "Last name",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Password",
"LOGIN_HELP_CREATE": "Optional: defaults to the last name in lower case.",
"LOGIN_HELP_EDIT": "Leave empty to keep it unchanged.",
"PASSWORD_HELP_CREATE": "Optional: defaults to the login.",
"PASSWORD_HELP_EDIT": "Leave empty to keep it unchanged.",
"ACCOUNT_SECTION": "User account"
},
"DOCTORS": {
"TITLE": "Doctors",
"ADD": "Add a doctor",
"EDIT": "Edit a doctor",
"EMPTY": "No doctors.",
"DELETE_CONFIRM": "Delete this doctor, their time slots and their user account?",
"ADDED": "Doctor {name} has been added (login: {login}).",
"UPDATED": "Doctor {name} has been updated.",
"DELETED": "Doctor {name} has been deleted."
},
"CLIENTS": {
"TITLE": "Patients",
"ADD": "Add a patient",
"EDIT": "Edit a patient",
"EMPTY": "No patients.",
"DELETE_CONFIRM": "Delete this patient, their user account and all their appointments?",
"ADDED": "Patient {name} has been added (login: {login}).",
"UPDATED": "Patient {name} has been updated.",
"DELETED": "Patient {name} has been deleted."
},
"ERROR_PAGE": {
"TITLE": "Error",
"BACK": "Back to the home page"
},
"ERRORS": {
"LOGIN_TAKEN": "This login is already used by another account.",
"DOCTOR_ALREADY_EXISTS": "A doctor with this first and last name already exists.",
"PATIENT_ALREADY_EXISTS": "A patient with this first and last name already exists.",
"DOCTOR_HAS_APPOINTMENTS": "This doctor has appointments: cancel them before deleting the doctor.",
"SLOT_ALREADY_BOOKED": "This slot has just been booked by someone else.",
"CONCURRENT_UPDATE": "This record was changed by another user in the meantime. Go back to the list and reopen it before trying again.",
"DOCTOR_NOT_FOUND": "This doctor does not exist (any more).",
"PATIENT_NOT_FOUND": "This patient does not exist (any more).",
"SLOT_NOT_FOUND": "This slot does not exist (any more).",
"APPOINTMENT_NOT_FOUND": "This appointment does not exist (any more).",
"INVALID_DATE": "The requested date is not valid.",
"CHOOSE_PATIENT": "Choose a patient.",
"INVALID_FORM": "The form contains errors.",
"INVALID_TITLE": "Choose a title from the list.",
"FIRSTNAME_REQUIRED": "The first name is required.",
"FIRSTNAME_TOO_LONG": "The first name must not exceed 20 characters.",
"LASTNAME_REQUIRED": "The last name is required.",
"LASTNAME_TOO_LONG": "The last name must not exceed 20 characters.",
"INVALID_LOGIN": "At most 30 characters: unaccented lower-case letters, digits, dot, hyphen, underscore.",
"PASSWORD_TOO_LONG": "The password must not exceed 72 characters.",
"SESSION_EXPIRED": "Your session has expired: please log in again.",
"BAD_REQUEST": "The request is invalid.",
"FORBIDDEN": "Your role does not allow you to access this page.",
"NOT_FOUND": "This page does not exist.",
"SERVER_ERROR": "An unexpected error occurred. Please try again later.",
"TOO_MANY_ATTEMPTS": "Too many failed attempts. Try again in {minutes} minute(s).",
"WRONG_CAPTCHA": "The characters you typed do not match the image. A new image is shown.",
"TOO_MANY_ACCOUNTS": "Too many accounts have been created from your connection. Try again in {minutes} minute(s).",
"LOGIN_REQUIRED": "The login is required.",
"PASSWORD_REQUIRED": "The password is required.",
"PASSWORD_TOO_SHORT": "The password must be at least {min} characters long.",
"CONFIRMATION_REQUIRED": "Please confirm the password.",
"PASSWORDS_DIFFER": "The confirmation does not match the password.",
"CURRENT_PASSWORD_REQUIRED": "Enter your current password.",
"WRONG_CURRENT_PASSWORD": "Incorrect current password.",
"PAST_DATE": "Appointments cannot be booked for a past date.",
"PATIENT_HAS_UPCOMING_APPOINTMENT": "This patient already has an upcoming appointment: it must be cancelled before booking another one.",
"CAPTCHA_BEFORE_ACCOUNT": "To create an account, first type the characters shown in the image correctly, then click \"Create a patient account\".",
"AUTH_REQUIRED": "Please log in to access this page.",
"JSON_REQUIRED": "Request refused: the server expects JSON.",
"SERVER_UNREACHABLE": "The server does not respond. Please try again later."
},
"CAPTCHA": {
"LABEL": "Type the characters shown in the image",
"IMAGE_ALT": "Anti-robot verification image",
"NEW_IMAGE": "Another image",
"HELP": "Upper or lower case, it does not matter."
},
"REGISTRATION": {
"TITLE": "Create a patient account",
"INTRO": "With this account you can book your own appointments.",
"LOGIN_HELP": "Unaccented lower-case letters, digits, dot, hyphen, underscore.",
"PASSWORD_HELP": "At least {min} characters.",
"SUBMIT": "Create my account",
"BACK_TO_LOGIN": "Back to login",
"DONE": "Your account has been created. You can now log in with the login {login}."
},
"ACCOUNT": {
"CONFIRMATION_LABEL": "Confirm password"
},
"AREA": {
"TITLE": "My area",
"HELLO": "Hello {name}",
"MANAGE_ACCOUNT": "Manage my account",
"MANAGE_ACCOUNT_HELP": "Change my details or password, or delete my account.",
"VIEW_SCHEDULE": "View a schedule",
"VIEW_SCHEDULE_HELP": "See a doctor's schedule and book a slot.",
"MY_APPOINTMENT": "My appointment",
"SEE_IN_SCHEDULE": "see in the schedule",
"CANCEL_APPOINTMENT": "Cancel this appointment",
"NO_APPOINTMENT": "You have no upcoming appointment."
},
"MY_ACCOUNT": {
"TITLE": "Manage my account",
"NEW_PASSWORD_LABEL": "New password",
"CURRENT_PASSWORD_LABEL": "Current password",
"CURRENT_PASSWORD_HELP": "Required to save any change.",
"BACK": "Back to my area",
"DELETE_TITLE": "Delete my account",
"DELETE_HELP": "Your account will be permanently deleted, together with all your appointments.",
"DELETE_CONFIRM": "Permanently delete your account? Any appointment you have will be cancelled.",
"DELETE_SUBMIT": "Delete my account",
"UPDATED": "Your account has been updated.",
"DELETED": "Your account has been deleted."
},
"CONFIRMATION": {
"TITLE": "Confirmation",
"NO": "No, go back",
"YES": "Yes, confirm"
}
}
|
10.9. Die Stores
10.9.1. src/stores/session.ts
| // =========================================================================
// stores/session.ts - WER ist angemeldet?
// -------------------------------------------------------------------------
// Der Pinia-Store der Sitzung: der angemeldete Benutzer (oder null) und das,
// was sich daraus ableitet (ist der Benutzer ein ADMIN? ein Patient?).
//
// Das JWT-Token selbst ist NICHT hier: Es liegt in einem httpOnly-Cookie, das
// nur der Browser verwaltet. Der Store behält nur die BESCHREIBUNG
// des Benutzers, die der Server zurückgibt ({ login, name, role }).
//
// Beim Start (und nach einem F5) ist der Store leer: check() fragt den
// Server, nur einmal, wer angemeldet ist (GET /api/auth/me).
// =========================================================================
import { computed, ref } from 'vue';
import { defineStore } from 'pinia';
import { rdvApi } from '../api/rdvmedecins.api';
import type { Role, User } from '../api/types';
export const useSessionStore = defineStore('session', () => {
const user = ref<User | null>(null);
// wurde dem Server die Frage "Wer ist angemeldet?" bereits gestellt?
let checking: Promise<void> | null = null;
const loggedIn = computed(() => user.value !== null);
const role = computed<Role | null>(() => user.value?.role ?? null);
const isAdmin = computed(() => role.value === 'ADMIN');
const isPatient = computed(() => role.value === 'USER');
// ADMIN und DOCTOR: Termine beliebiger Patienten buchen und stornieren
const isManager = computed(() => role.value === 'ADMIN' || role.value === 'DOCTOR');
// die Startseite jeder Rolle, direkt nach dem Login
const homePage = computed(() => (isPatient.value ? '/my-area' : '/schedule'));
// vom Router-Guard vor JEDER Navigation aufgerufen; fragt den
// Server nur beim ersten Mal (das Promise wird behalten und wiederverwendet)
function check(): Promise<void> {
checking ??= rdvApi
.me()
.then((u) => {
user.value = u;
})
.catch(() => {
user.value = null; // 401: niemand; oder Server nicht erreichbar
});
return checking;
}
async function logIn(login: string, password: string, captchaId: string, captcha: string): Promise<void> {
user.value = await rdvApi.logIn(login, password, captchaId, captcha);
}
// der Benutzer hat Namen oder Login geändert (PUT /api/my-account)
function update(u: User): void {
user.value = u;
}
async function logOut(): Promise<void> {
try {
await rdvApi.logOut();
} finally {
forget();
}
}
// ohne den Server etwas zu fragen: Sitzung abgelaufen, Konto gelöscht
function forget(): void {
user.value = null;
}
return {
user,
loggedIn,
role,
isAdmin,
isPatient,
isManager,
homePage,
check,
logIn,
update,
logOut,
forget,
};
});
|
- Zeile 21: der angemeldete Benutzer, wie ihn der Server beschreibt. Das Token selbst ist nicht dabei – es steckt in einem Cookie, das nur der Browser verarbeitet;
- Zeilen 25–30: was daraus abgeleitet wird und von den Seiten und der Navigationsleiste verwendet wird;
- Zeile 33: die Startseite jeder Rolle: „Mein Bereich“ für einen Patienten, der Terminkalender für die übrigen;
- Zeilen 37–47: die Frage „Wer ist angemeldet?“, die dem Server nur beim ERSTEN Mal gestellt wird. Das Promise wird in [checking] aufbewahrt: Spätere Aufrufe verwenden es wieder (der Operator [??=] weist nur dann einen Wert zu, wenn die Variable [null] oder [undefined] ist). Sie kann nicht fehlschlagen: Ein Fehler (401, Server nicht erreichbar) bedeutet „niemand“;
- Zeilen 49–51: die Anmeldung. Schlägt sie fehl, lehnt [rdvApi.logIn] sein Promise mit einem [ApiError] ab, der diese Funktion durchläuft und bei der Anmeldeseite ankommt;
- Zeile 54: Nach Änderungen an seinem Konto kann der Patient seinen Namen geändert haben;
- Zeilen 58–64: [finally]: Der Benutzer wird vergessen, auch wenn der Server nicht geantwortet hat;
- Zeile 67: ohne irgendeine Anfrage an den Server (Sitzung abgelaufen, Konto gelöscht).
10.9.2. src/stores/messages.ts
| // =========================================================================
// stores/messages.ts - die dem Benutzer angezeigten Meldungen
// -------------------------------------------------------------------------
// Dieselbe Darstellung wie in der HTML-Anwendung:
// - ein ERFOLG wird OBEN auf der Seite angezeigt (grünes Banner);
// - ein FEHLER UNTEN, auf hellrosa Hintergrund ("sticky"-Panel).
// Eine Meldung ist ein Übersetzungs-SCHLÜSSEL (+ seine Parameter): Sie wird daher
// von selbst neu übersetzt, wenn der Benutzer die Sprache wechselt.
//
// Die "Flash"-Meldungen: Eine Aktion, die mit einem Seitenwechsel endet
// (Buchung, Hinzufügen eines Arztes ...), hinterlässt ihre Meldung mit flash();
// sie wird auf der NÄCHSTEN Seite angezeigt und verschwindet bei der folgenden
// Navigation (siehe router.afterEach in router.ts). Auf der Serverseite übernahm das
// das kurzlebige Cookie "rdvmedecins_flash".
// =========================================================================
import { ref } from 'vue';
import { defineStore } from 'pinia';
import { ApiError } from '../api/http-client';
export interface Message {
key: string;
params?: Record<string, string>;
}
export const useMessagesStore = defineStore('messages', () => {
const success = ref<Message | null>(null);
const error = ref<Message | null>(null);
// die auf der nächsten Seite anzuzeigenden Meldungen
let pending: { success: Message | null; error: Message | null } | null = null;
function showSuccess(key: string, params?: Record<string, string>): void {
success.value = { key, params };
error.value = null;
}
function showError(key: string, params?: Record<string, string>): void {
error.value = { key, params };
success.value = null;
}
// ein ApiError -> die Meldung der Seite; jeder andere Fehler ist eine
// Anomalie des Clients, die durchgelassen wird (Browser-Konsole)
function showApiError(e: unknown): void {
if (!(e instanceof ApiError)) {
throw e;
}
showError(e.key, e.params);
}
function clear(): void {
success.value = null;
error.value = null;
}
// für die NÄCHSTE Seite
function flash(type: 'success' | 'error', key: string, params?: Record<string, string>): void {
pending ??= { success: null, error: null };
pending[type] = { key, params };
}
// nach jeder Navigation aufgerufen (router.afterEach)
function newPage(): void {
success.value = pending?.success ?? null;
error.value = pending?.error ?? null;
pending = null;
}
return { success, error, showSuccess, showError, showApiError, clear, flash, newPage };
});
|
- Zeilen 21–24: Eine Meldung besteht aus einem Übersetzungsschlüssel und seinen Parametern. Sie übersetzt sich daher automatisch, wenn der Benutzer die Sprache wechselt;
- Zeilen 27–28: die Erfolgsmeldung (oben angezeigt) und die Fehlermeldung (unten) der aktuellen Seite;
- Zeilen 44–49: Ein [ApiError] wird zur Meldung der Seite. Jeder andere Fehler ist eine Anomalie des CLIENTS (ein Programmierfehler): Er darf protokolliert werden und wird in der Browser-Konsole angezeigt;
- Zeilen 57–60: eine Meldung für die NÄCHSTE Seite. Eine Aktion, die zu einem Seitenwechsel führt (Buchung, Hinzufügen eines Arztes, Anmeldung nach der Kontoerstellung), zeigt diese Meldung an, bevor zur nächsten Seite navigiert wird;
- Zeilen 63–67: wird nach jeder Seitennavigation aufgerufen (siehe [router.ts]): Die Meldungen der vorherigen Seite verschwinden, und ausstehende Meldungen erscheinen. In der HTML-Anwendung war dies die Aufgabe des kurzlebigen Cookies [rdvmedecins_flash].
10.10. Die Composables
10.10.1. src/composables/useConfirmation.ts
Das Composable aus Beispiel 12, mit drei Unterschieden:
| // =========================================================================
// composables/useConfirmation.ts - "Sind Sie sicher?"
// -------------------------------------------------------------------------
// Übernommen aus Beispiel 12: confirm(key) öffnet den Bestätigungsdialog
// (components/ConfirmDialog.vue, einmal in App.vue platziert) und
// gibt ein Promise zurück, das mit true (Ja) oder false (Nein) aufgelöst wird. Die Meldung ist
// ein Übersetzungs-SCHLÜSSEL: Der Dialog übersetzt ihn in die aktuelle Sprache.
//
// if (await confirm('SCHEDULE.CANCEL_CONFIRM')) { ... }
// =========================================================================
import { readonly, ref } from 'vue';
import { useMessagesStore } from '../stores/messages';
const messageKey = ref<string | null>(null); // null: Dialog geschlossen
let answer: ((yes: boolean) => void) | null = null;
export function useConfirmation() {
function confirm(key: string): Promise<boolean> {
answer?.(false); // eine noch offene Frage? Sie zählt als "Nein"
// eine neue Frage: Die Meldungen der vorherigen Aktion sind veraltet
useMessagesStore().clear();
messageKey.value = key;
return new Promise<boolean>((resolve) => {
answer = resolve;
});
}
function respond(yes: boolean): void {
messageKey.value = null;
const r = answer;
answer = null;
r?.(yes);
}
return { messageKey: readonly(messageKey), confirm, respond };
}
|
- Zeile 19: Die Meldung ist ein Übersetzungsschlüssel: Das Fenster übersetzt ihn in die aktuelle Sprache;
- Zeile 20: Eine noch offene Frage (unwahrscheinliches Szenario) erhält die Antwort „Nein“;
- Zeile 22: Eine neue Frage macht die Meldungen der vorherigen Aktion hinfällig.
| // =========================================================================
// composables/useFormatting.ts - die Anzeige von Personen, Uhrzeiten und Tagen
// -------------------------------------------------------------------------
// Der Server sendet ROHDATEN (startHour: 8, startMinute: 0; day:
// "2026-10-05"); die Formatierung, die von der Sprache abhängt, ist Sache
// des Clients. longDate() folgt der aktuellen Sprache von vue-i18n.
// =========================================================================
import { useI18n } from 'vue-i18n';
import type { Slot, Identity } from '../api/types';
// "Mme Alice DURAND"
export function label(p: Identity): string {
return `${p.title} ${p.firstName} ${p.lastName}`;
}
// "8:05" statt "8:5"
export function time(h: number, m: number): string {
return `${h}:${String(m).padStart(2, '0')}`;
}
// "8:00 - 8:20"
export function timeRange(s: Slot): string {
return `${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}`;
}
// das heutige Datum im Format "yyyy-MM-dd" (das von <input type="date"> und der API)
export function today(): string {
const d = new Date();
return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}
// true, wenn [day] ein existierendes Datum im Format yyyy-MM-dd ist
export function isValidDate(day: unknown): day is string {
if (typeof day !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(day)) {
return false;
}
const date = new Date(`${day}T00:00:00Z`);
return !isNaN(date.getTime()) && date.toISOString().slice(0, 10) === day;
}
export function useFormatting() {
const { locale } = useI18n();
// "lundi 5 octobre 2026" / "Monday 5 October 2026"
function longDate(day: string): string {
return new Intl.DateTimeFormat(locale.value === 'en' ? 'en-GB' : 'fr-FR', {
dateStyle: 'full',
timeZone: 'UTC', // "2026-10-05T00:00:00Z" muss der 5. bleiben, unabhängig von der Zeitzone
}).format(new Date(`${day}T00:00:00Z`));
}
return { label, time, timeRange, longDate };
}
|
Der Server sendet Rohdaten ([startHour: 8, startMinute: 0], [day: "2026-10-05"]); die Formatierung dieser Daten, die von der Sprache abhängt, ist Sache des Clients:
- Zeilen 13–39: gewöhnliche, nicht reaktive Funktionen, einzeln exportiert;
- Zeilen 42–54: ein Composable, weil [longDate] die AKTUELLE Sprache benötigt, die es über [useI18n()] erhält. Ändert sich die Sprache, wird ein Template, das [longDate(...)] anzeigt, neu berechnet;
- Zeile 49: [new Date("2026-10-05T00:00:00Z")] ist Mitternacht UTC; in der Zeitzone von Paris angezeigt, wäre es immer noch der 5. Oktober, in New York aber der 4. Oktober! Wir fordern daher eine Anzeige in der Zeitzone UTC an.
| // =========================================================================
// composables/useForm.ts - die Fehler eines an den Server gesendeten Formulars
// -------------------------------------------------------------------------
// Alle Formulare der Anwendung folgen demselben Muster wie
// Beispiel 20: Keine Regel wird im Browser geprüft (sie
// liegen an EINER einzigen Stelle, dem Server), und bei Ablehnung:
// - wird der Fehler jedes Feldes (ApiError.fields) unter dem Feld angezeigt,
// rot umrandet;
// - wird die allgemeine Meldung (ApiError.key) am Seitenende angezeigt.
// Dieses Composable bündelt diesen Zustand und diese Aktionen.
// =========================================================================
import { ref } from 'vue';
import { ApiError } from '../api/http-client';
import { useMessagesStore } from '../stores/messages';
export function useForm() {
const messages = useMessagesStore();
const errors = ref<Record<string, string>>({}); // Feld -> Meldungsschlüssel
const params = ref<Record<string, string>>({}); // Parameter der Meldungen ({min} ...)
const submitting = ref(false);
function clearErrors(): void {
errors.value = {};
params.value = {};
}
// führt das Absenden aus; gibt true zurück, wenn es erfolgreich war. Bei einem ApiError
// werden die Fehler angezeigt und false zurückgegeben.
async function submit(action: () => Promise<void>): Promise<boolean> {
clearErrors();
submitting.value = true;
try {
await action();
return true;
} catch (e) {
if (e instanceof ApiError) {
errors.value = e.fields;
params.value = e.params;
}
messages.showApiError(e);
return false;
} finally {
submitting.value = false;
}
}
return { errors, params, submitting, submit, clearErrors };
}
|
Alle Formulare der Anwendung folgen dem in Beispiel 20 gezeigten Ansatz: Im Browser werden keine Regeln validiert; der Server validiert alles, und etwaige Fehler werden unter den Feldern angezeigt. Dieses Composable bündelt den gemeinsamen Zustand und die gemeinsamen Aktionen:
- Zeilen 19–21: der Fehler für jedes Feld, die Meldungsparameter und ein Sendeindikator (die Schaltfläche ist während des Sendens deaktiviert, um einen Doppelklick zu verhindern);
- Zeilen 30–46: führt das Senden aus (eine von der Seite bereitgestellte Funktion); tritt ein [ApiError] auf, löscht es die Feldfehler, zeigt die allgemeine Meldung am unteren Seitenrand an und liefert [false] zurück.
10.11. Der Router
| // =========================================================================
// router.ts - die Seiten der Anwendung und ihre Zugriffsrechte
// -------------------------------------------------------------------------
// Dieselben Adressen wie in der HTML-Anwendung (/login, /schedule, /doctors,
// /my-area ...), aber jetzt sind es Routen des CLIENTS:
// createWebHistory erzeugt "saubere" Adressen ohne #. Der Browser
// sendet nur für die allererste Seite eine Anfrage an den Server; danach
// ändert der Router die Adresse und die angezeigte Komponente.
//
// Die Kehrseite: Lädt der Benutzer /schedule neu (F5),
// fordert der Browser tatsächlich /schedule vom Server an, der dann
// index.html zurückgeben muss (Vite tut das in der Entwicklung; in der Produktion siehe
// web/client-spa.ts des JSON-Servers).
//
// Jede Route trägt Metadaten (meta):
// - title : Übersetzungsschlüssel des Tab-Titels;
// - public : ohne Anmeldung zugänglich;
// - roles : die erlaubten Rollen (fehlt = alle angemeldeten Rollen);
// - type : 'doctors' oder 'clients' für die beiden gemeinsamen Seiten.
//
// ZUR ERINNERUNG: Diese Prüfungen sind nur eine BEQUEMLICHKEIT (eine nutzlose
// Seite nicht anzuzeigen). Die Daten werden vom Server geschützt, der
// Token und Rolle bei JEDER Anfrage erneut prüft.
// =========================================================================
import { createRouter, createWebHistory } from 'vue-router';
import type { Role } from './api/types';
import type { PersonType } from './api/rdvmedecins.api';
import { i18n } from './i18n';
import { useSessionStore } from './stores/session';
import { useMessagesStore } from './stores/messages';
import { rdvApi } from './api/rdvmedecins.api';
import LoginView from './views/LoginView.vue';
import ScheduleView from './views/ScheduleView.vue';
declare module 'vue-router' {
interface RouteMeta {
title: string;
public?: boolean;
roles?: Role[];
type?: PersonType;
}
}
// die Routen zur Verwaltung von Ärzten UND Clients (ADMIN), nach demselben Muster
function personRoutes(type: PersonType, title: string, addTitle: string, editTitle: string) {
const roles: Role[] = ['ADMIN'];
return [
{ path: `/${type}`, name: type, component: () => import('./views/PersonsView.vue'), meta: { title, roles, type } },
{
path: `/${type}/add`,
name: `${type}-add`,
component: () => import('./views/PersonFormView.vue'),
meta: { title: addTitle, roles, type },
},
{
path: `/${type}/:id(\\d+)/edit`, // (\\d+): Die id muss eine Zahl sein
name: `${type}-edit`,
component: () => import('./views/PersonFormView.vue'),
props: (route: { params: { id?: string | string[] } }) => ({ id: Number(route.params.id) }),
meta: { title: editTitle, roles, type },
},
];
}
export const router = createRouter({
history: createWebHistory(),
routes: [
// "/": nach /login, das bei Anmeldung selbst zur Startseite der Rolle weiterleitet
{ path: '/', redirect: '/login' },
{ path: '/login', name: 'login', component: LoginView, meta: { title: 'LOGIN.TITLE', public: true } },
{ path: '/schedule', name: 'schedule', component: ScheduleView, meta: { title: 'SCHEDULE.PAGE_TITLE' } },
...personRoutes('doctors', 'DOCTORS.TITLE', 'DOCTORS.ADD', 'DOCTORS.EDIT'),
...personRoutes('clients', 'CLIENTS.TITLE', 'CLIENTS.ADD', 'CLIENTS.EDIT'),
{
path: '/register',
name: 'register',
component: () => import('./views/RegisterView.vue'),
meta: { title: 'REGISTRATION.TITLE', public: true },
// ein für die Route SPEZIFISCHER Guard: ohne Pass (auf der Login-Seite gelöstes
// CAPTCHA) zurück zur Login-Seite
beforeEnter: async () => {
const { valid } = await rdvApi.registrationAccessStatus().catch(() => ({ valid: false }));
if (!valid) {
useMessagesStore().flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
return { name: 'login' };
}
return true;
},
},
{
path: '/my-area',
name: 'my-area',
component: () => import('./views/PatientAreaView.vue'),
meta: { title: 'AREA.TITLE', roles: ['USER'] },
},
{
path: '/my-account',
name: 'my-account',
component: () => import('./views/MyAccountView.vue'),
meta: { title: 'MY_ACCOUNT.TITLE', roles: ['USER'] },
},
{
path: '/forbidden',
name: 'forbidden',
component: () => import('./views/ErrorView.vue'),
props: { code: 403 },
meta: { title: 'ERROR_PAGE.TITLE' },
},
{
path: '/:pathMatch(.*)*',
name: 'not-found',
component: () => import('./views/ErrorView.vue'),
props: { code: 404 },
meta: { title: 'ERROR_PAGE.TITLE', public: true },
},
],
});
// -------------------------------------------------------------------------
// der GLOBALE Guard, vor jeder Navigation
// -------------------------------------------------------------------------
router.beforeEach(async (to) => {
const session = useSessionStore();
// beim ersten Mal (Start, F5): Wir fragen den Server, wer angemeldet ist
await session.check();
if (to.meta.public) {
// bereits angemeldet: Die Login-Seite ergibt keinen Sinn mehr
if (to.name === 'login' && session.loggedIn) {
return session.homePage;
}
return true;
}
if (!session.loggedIn) {
// die angeforderte Seite wird gemerkt, um nach dem Login zu ihr zurückzukehren
return { name: 'login', query: { redirect: to.fullPath } };
}
if (to.meta.roles && !to.meta.roles.includes(session.role!)) {
return { name: 'forbidden' };
}
return true;
});
// -------------------------------------------------------------------------
// nach jeder Navigation: "Flash"-Meldungen, Tab-Titel
// -------------------------------------------------------------------------
router.afterEach((to, from) => {
// eine Navigation, die nur die Query ändert (/schedule?...), ist trotzdem eine
// neue "Seite": Wie bei der HTML-Anwendung verschwinden die Meldungen der
// vorherigen Seite, die Flash-Meldungen erscheinen
if (to.fullPath !== from.fullPath) {
useMessagesStore().newPage();
}
document.title = `${i18n.global.t(to.meta.title)} - ${i18n.global.t('APP.TITLE')}`;
});
|
- Zeilen 36–43: Metadaten unserer Routen: der Tab-Titel (ein Übersetzungsschlüssel), öffentlicher Zugriff, zugelassene Rollen und Benutzertyp;
- Zeilen 46–64: die drei Routen der Arztverwaltung (Liste, Hinzufügen, Bearbeiten) und dieselben drei für Clients, von einer Funktion erzeugt. Die Seiten werden bei Bedarf geladen ([() => import(...)]): Ein Patient lädt den Code der Arztverwaltung nie herunter;
- Zeile 57: [(\d+)]: Ein regulärer Ausdruck beschränkt den Parameter [id] auf Zahlen. [/doctors/abc/edit] passt nicht zu dieser Route: Die Seite „Seite nicht gefunden“ wird angezeigt;
- Zeile 60: die Eigenschaft [id] der Komponente, in eine Zahl umgewandelt;
- Zeile 67: „saubere“ Adressen, ohne [#];
- Zeile 70: Die Adresse [/] führt zu [/login], das wiederum bei angemeldetem Benutzer zur Startseite der Rolle führt;
- Zeilen 82–89: ein Guard, der SPEZIFISCH für eine Route gilt und vor deren Betreten ausgeführt wird: Ohne Berechtigungsnachweis (auf der Anmeldeseite gelöstes CAPTCHA) leitet die Kontoerstellung mit einer Meldung zur Anmeldeseite um;
- Zeile 107: [props] kann auch ein statisches Objekt sein: Dieselbe Fehlerseite wird für 403- und 404-Fehler verwendet;
- Zeilen 123–143: Der GLOBALE Guard, vor jeder Navigation:
- [await session.check()]: Beim ersten Mal (beim Start, F5) wird der Server gefragt, wer angemeldet ist. Der Guard ist [async]: Die Navigation wartet auf die Antwort;
- eine öffentliche Seite ist immer zugänglich; die Anmeldeseite leitet einen angemeldeten Benutzer jedoch zu seiner Startseite um;
- nicht angemeldet: Anmeldeseite, wobei die angeforderte Seite gemerkt wird;
- ungültige Rolle: 403-Seite;
- Zeilen 148–156: nach jeder Navigation: Die Flash-Meldungen werden angezeigt, und der Tab-Titel wird übersetzt. [i18n.global.t]: Außerhalb einer Komponente wird das Objekt [i18n] direkt verwendet.
10.12. Die Komponenten
10.12.1. src/components/NavBar.vue
| <!--
=========================================================================
components/NavBar.vue - the navigation bar
-------------------------------------------------------------------------
Same content as that of the HTML application (views/partials/navbar.hbs):
title, menus according to the role, FR / EN, role, name, logout.
"Doctors" and "Patients" appear only for the ADMIN: a mere display
convenience, the real protection being that of the server.
=========================================================================
-->
<script setup lang="ts">
import { RouterLink, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { useSessionStore } from '../stores/session';
import { changeLanguage, LANGUAGES } from '../i18n';
const { t, locale } = useI18n();
const session = useSessionStore();
const router = useRouter();
async function logOut(): Promise<void> {
await session.logOut().catch(() => {}); // auch wenn der Server nicht antwortet
router.push({ name: 'login' });
}
</script>
<template>
<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>
<ul v-if="session.loggedIn" class="navbar-nav me-auto">
<li v-if="session.isPatient" class="nav-item">
<!-- active-class: die Bootstrap-Klasse des Menüs der angezeigten Seite -->
<RouterLink class="nav-link" active-class="active" to="/my-area">{{ t('APP.MENU_MY_AREA') }}</RouterLink>
</li>
<li class="nav-item">
<RouterLink class="nav-link" active-class="active" to="/schedule">{{ t('APP.MENU_SCHEDULE') }}</RouterLink>
</li>
<template v-if="session.isAdmin">
<li class="nav-item">
<RouterLink class="nav-link" active-class="active" to="/doctors">{{ t('APP.MENU_DOCTORS') }}</RouterLink>
</li>
<li class="nav-item">
<RouterLink class="nav-link" active-class="active" to="/clients">{{ t('APP.MENU_PATIENTS') }}</RouterLink>
</li>
</template>
</ul>
<div v-else class="me-auto"></div>
<div class="d-flex align-items-center gap-2">
<!-- FR / EN: keine Anfrage an den Server, die Seite wird an Ort und Stelle neu übersetzt -->
<div class="btn-group btn-group-sm" role="group" :aria-label="t('APP.LANGUAGE')">
<button
v-for="l in LANGUAGES"
:key="l"
type="button"
class="btn"
:class="locale === l ? 'btn-light' : 'btn-outline-light'"
:aria-pressed="locale === l"
@click="changeLanguage(l)"
>
{{ l.toUpperCase() }}
</button>
</div>
<template v-if="session.user">
<span class="badge text-bg-light text-primary">{{ session.user.role }}</span>
<span class="text-white">{{ session.user.name }}</span>
<button type="button" class="btn btn-sm btn-outline-light" @click="logOut">{{ t('APP.LOGOUT') }}</button>
</template>
</div>
</nav>
</template>
|
- Zeilen 21–24: Abmeldung, gefolgt von der Anmeldeseite. [.catch(() => {})]: Auch wenn der Server nicht antwortet, meldet sich der Client ab;
- Zeile 31: Die Menüs erscheinen erst nach der Anmeldung, je nach Rolle: „Mein Bereich“ für einen Patienten, „Ärzte“ und „Patienten“ für ADMIN. Dies dient lediglich der Anzeigekonvenienz; die eigentliche Sicherheit gewährleistet der Server;
- Zeile 34: Das Menü der angezeigten Seite erhält die Klasse [active];
- Zeilen 53–63: die Schaltflächen FR / EN. [:aria-pressed] teilt Screenreadern mit, welche Schaltfläche gedrückt ist;
- Zeile 66: die Rolle, der Name und die Abmeldefunktion.
10.12.2. src/components/SuccessMessage.vue und ErrorPanel.vue
| <!--
components/SuccessMessage.vue - the SUCCESS message, at the top of the page
(appointment booked, doctor added...) - see stores/messages.ts.
role="status": a screen reader announces it without interrupting the user.
-->
<script setup lang="ts">
import { useI18n } from 'vue-i18n';
import { useMessagesStore } from '../stores/messages';
const { t } = useI18n();
const messages = useMessagesStore();
</script>
<template>
<div v-if="messages.success" class="alert alert-success" role="status">
{{ t(messages.success.key, messages.success.params ?? {}) }}
</div>
</template>
|
| <!--
components/ErrorPanel.vue - the error panel, at the BOTTOM of each page, on a
light pink background (class .error-panel, see styles.css) - like
views/partials/errors.hbs of the HTML application.
role="alert": a screen reader announces the message as soon as it appears.
-->
<script setup lang="ts">
import { useI18n } from 'vue-i18n';
import { useMessagesStore } from '../stores/messages';
const { t } = useI18n();
const messages = useMessagesStore();
</script>
<template>
<div v-if="messages.error" class="error-panel" role="alert">
{{ t(messages.error.key, messages.error.params ?? {}) }}
</div>
</template>
|
Zwei sehr kurze Komponenten, die die Meldungen aus dem Store [messages] in der aktuellen Sprache anzeigen:
- Zeile 16: Ein Screenreader kündigt die Fehlermeldung an, sobald sie erscheint, auch wenn sie sich am unteren Seitenrand befindet; die Erfolgsmeldung ist [role="status"] und wird angekündigt, ohne den Benutzer zu unterbrechen.
10.12.3. src/components/ConfirmDialog.vue
| <!--
=========================================================================
components/ConfirmDialog.vue - the "Are you sure?" dialog
-------------------------------------------------------------------------
The one of example 12, completed for the keyboard like public/js/app.js
of the HTML application:
- on opening, the focus goes to "No, go back": an absent-minded press on
Enter deletes nothing;
- Escape closes the dialog (= No);
- Tab and Shift+Tab stay INSIDE the dialog (otherwise the focus would go to
the greyed-out page, behind);
- on closing, the focus goes back to the element that had it (the
"Delete" button clicked, for example).
"No, go back" rather than "Cancel": the question is sometimes "Cancel this
appointment?", and a "Cancel" button would be ambiguous there.
=========================================================================
-->
<script setup lang="ts">
import { nextTick, useTemplateRef, watch } from 'vue';
import { useI18n } from 'vue-i18n';
import { useConfirmation } from '../composables/useConfirmation';
const { t } = useI18n();
const { messageKey, respond } = useConfirmation();
const dialog = useTemplateRef<HTMLElement>('dialog');
const noButton = useTemplateRef<HTMLButtonElement>('noButton');
let previousFocus: HTMLElement | null = null;
watch(messageKey, async (key, oldKey) => {
if (key !== null && oldKey === null) {
previousFocus = document.activeElement as HTMLElement | null;
await nextTick(); // der Dialog befindet sich jetzt in der Seite
noButton.value?.focus();
} else if (key === null) {
previousFocus?.focus();
previousFocus = null;
}
});
function onKeydown(e: KeyboardEvent): void {
if (e.key === 'Escape') {
respond(false);
} else if (e.key === 'Tab' && dialog.value) {
const buttons = [...dialog.value.querySelectorAll<HTMLButtonElement>('button')];
const first = buttons[0];
const last = buttons[buttons.length - 1];
if (e.shiftKey && document.activeElement === first) {
e.preventDefault();
last?.focus();
} else if (!e.shiftKey && document.activeElement === last) {
e.preventDefault();
first?.focus();
}
}
}
</script>
<template>
<Teleport to="body">
<div v-if="messageKey !== null" @keydown="onKeydown">
<div class="modal-backdrop fade show"></div>
<div
ref="dialog"
class="modal fade show d-block"
tabindex="-1"
role="alertdialog"
aria-modal="true"
aria-labelledby="confirmation-title"
aria-describedby="confirmation-message"
@click.self="respond(false)"
>
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 id="confirmation-title" class="modal-title">{{ t('CONFIRMATION.TITLE') }}</h5>
<button type="button" class="btn-close" :aria-label="t('BOOKING_DIALOG.CLOSE_ARIA')" @click="respond(false)"></button>
</div>
<div class="modal-body">
<p id="confirmation-message" class="mb-0">{{ t(messageKey) }}</p>
</div>
<div class="modal-footer">
<button ref="noButton" type="button" class="btn btn-secondary" @click="respond(false)">{{ t('CONFIRMATION.NO') }}</button>
<button type="button" class="btn btn-danger" @click="respond(true)">{{ t('CONFIRMATION.YES') }}</button>
</div>
</div>
</div>
</div>
</div>
</Teleport>
</template>
|
Das Fenster aus Beispiel 12, für die Tastaturnavigation erweitert, mit dem Skript [public/js/app.js] der HTML-Anwendung:
- Zeilen 29–38: Beim Öffnen wird das Element, das den Fokus hatte (zum Beispiel die angeklickte Schaltfläche „Löschen“), gemerkt; dann erhält die Schaltfläche „Nein, zurück“ den Fokus; beim Schließen geht der Fokus an das gemerkte Element zurück. Wer mit der Tastatur navigiert, findet so wieder an seine Stelle auf der Seite;
- Zeilen 40–55: Esc wird als „Nein“ behandelt; Tab und Umschalt+Tab bleiben innerhalb des Fensters: Nach der letzten Schaltfläche springt Tab zur ersten zurück (sonst würde der Fokus auf die ausgegraute Seite dahinter wandern);
- Zeile 60: Die Tastatureingaben werden vom Fenster selbst verarbeitet: Es ist nicht nötig, einen Listener am Dokument anzubringen oder zu entfernen;
- Zeile 68: für Screenreader der Titel und die Meldung des Fensters;
- Zeile 79: die übersetzte Meldung.
Ein vollständiges Formularfeld, von allen Formularen der Anwendung wiederverwendet:
| <!--
=========================================================================
components/InputField.vue - a complete form field
-------------------------------------------------------------------------
Label + field + help message OR error message, with v-model (see
example 08). All the forms of the application use it:
<InputField v-model="form.lastName" id="lastName" label="PERSONS.LASTNAME_LABEL"
:error="errors.lastName" :params="params" :maxlength="20" />
label, help and error are translation KEYS. An error outlines the
field in red (Bootstrap class is-invalid) and replaces the help.
=========================================================================
-->
<script setup lang="ts">
import { useI18n } from 'vue-i18n';
const model = defineModel<string>({ required: true });
withDefaults(
defineProps<{
id: string;
label: string;
type?: 'text' | 'password';
error?: string; // Schlüssel der Fehlermeldung dieses Feldes
params?: Record<string, string>; // Parameter der Meldungen ({min} ...)
help?: string; // Schlüssel der Hilfemeldung
maxlength?: number;
autocomplete?: string;
required?: boolean;
}>(),
{ type: 'text', error: undefined, params: () => ({}), help: undefined, maxlength: undefined, autocomplete: 'off', required: false },
);
const { t } = useI18n();
</script>
<template>
<div>
<label class="form-label" :for="id">{{ t(label) }}</label>
<input
:id="id"
v-model="model"
:type="type"
class="form-control"
:class="{ 'is-invalid': error }"
:maxlength="maxlength"
:autocomplete="autocomplete"
:required="required"
:aria-invalid="error ? 'true' : undefined"
:aria-describedby="`${id}-message`"
>
<div v-if="error" :id="`${id}-message`" class="invalid-feedback">{{ t(error, params) }}</div>
<div v-else-if="help" :id="`${id}-message`" class="form-text">{{ t(help, params) }}</div>
</div>
</template>
|
- Zeile 18: Das Feld wird mit [v-model] verwendet (siehe Beispiel 08);
- Zeilen 20–33: die Props: die Feld-ID und die Übersetzungsschlüssel für Beschriftung, Tooltip und Fehlermeldung;
- Zeile 46: Ein Fehler hebt das Feld rot hervor;
- Zeile 51: Die Hilfe- oder Fehlermeldung wird dem Feld für Screenreader zugeordnet;
- Zeilen 53–54: Die Fehlermeldung ERSETZT den Hilfetext.
In ein Elternelement eingebunden, erbt die Komponente auch die vom Elternelement weitergereichten Attribute, selbst wenn sie keine Props sind: [<InputField class="col-sm-6" ...>] fügt die Klasse [col-sm-6] ihrem Wurzelelement hinzu, [<div>] (man spricht von „vererbten“ Attributen, [fallthrough attributes]).
10.12.5. src/components/PersonFields.vue
Anrede, Vorname und Nachname sind drei Formularen gemeinsam:
| <!--
=========================================================================
components/PersonFields.vue - title, first name, last name
-------------------------------------------------------------------------
The identity fields, common to three forms: the ADMIN's doctor / client
form, "Create a patient account" and "Manage my account" (the equivalent of the
partial views/partials/personFields.hbs). Three named v-models:
<PersonFields v-model:title="f.title" v-model:firstName="f.firstName"
v-model:lastName="f.lastName" :errors="errors" />
=========================================================================
-->
<script setup lang="ts">
import { useI18n } from 'vue-i18n';
import InputField from './InputField.vue';
const title = defineModel<string>('title', { required: true });
const firstName = defineModel<string>('firstName', { required: true });
const lastName = defineModel<string>('lastName', { required: true });
defineProps<{ errors: Record<string, string> }>();
const { t } = useI18n();
const TITLES = ['Mr', 'Mme', 'Melle'];
</script>
<template>
<div class="mb-3">
<label class="form-label" for="title">{{ t('PERSONS.TITLE_LABEL') }}</label>
<select id="title" v-model="title" class="form-select" :class="{ 'is-invalid': errors.title }">
<option v-for="tt in TITLES" :key="tt" :value="tt">{{ tt }}</option>
</select>
<div v-if="errors.title" class="invalid-feedback">{{ t(errors.title) }}</div>
</div>
<div class="row g-3 mb-3">
<InputField v-model="firstName" class="col-sm-6" id="firstName" label="PERSONS.FIRSTNAME_LABEL" :error="errors.firstName" :maxlength="20" required />
<InputField v-model="lastName" class="col-sm-6" id="lastName" label="PERSONS.LASTNAME_LABEL" :error="errors.lastName" :maxlength="20" required />
</div>
</template>
|
- Zeilen 16–18: drei [v-model]-Felder mit Namen: Das Elternelement schreibt [v-model:title="..."], [v-model:firstName="..."], [v-model:lastName="..."];
- Zeile 34: Beide Textfelder sind [InputField]. [firstName] ist das [ref] von [defineModel]: Die Kette Elternelement -> PersonFields -> InputField -> [<input>] funktioniert in beide Richtungen.
Eine Komponente kann mehrere Wurzelelemente haben (hier das [<div>] für die Anrede und die Zeile mit den beiden Feldern): Man spricht von einem „Fragment“.
10.12.6. src/components/CaptchaField.vue
| <!--
=========================================================================
components/CaptchaField.vue - the captcha image and the input field
-------------------------------------------------------------------------
Loads a captcha (GET /api/captcha) when displayed. The parent gets
the input through v-model, and the identifier of the captcha through the exposed
method captchaId(); it calls reload() after each attempt, because an
image is used only ONCE (the server forgets it as soon as it has checked it).
defineExpose: what a PARENT component can call on this component,
thanks to a template ref (see LoginView.vue).
v-html: the SVG image is inserted as is. Harmless HERE because
it is built by our server (svg-captcha library) and does not
contain anything that comes from a user - see example 17.
=========================================================================
-->
<script setup lang="ts">
import { onMounted, ref } from 'vue';
import { useI18n } from 'vue-i18n';
import { rdvApi } from '../api/rdvmedecins.api';
import type { Captcha } from '../api/types';
const input = defineModel<string>({ required: true });
defineProps<{ error?: string }>();
const { t } = useI18n();
const captcha = ref<Captcha | null>(null);
async function reload(): Promise<void> {
input.value = '';
try {
captcha.value = await rdvApi.captcha();
} catch {
captcha.value = null; // Server nicht erreichbar: Der Login schlägt mit einer klaren Meldung fehl
}
}
defineExpose({ reload, captchaId: () => captcha.value?.id ?? '' });
onMounted(reload);
</script>
<template>
<div class="mb-3">
<label class="form-label" for="captcha">{{ t('CAPTCHA.LABEL') }}</label>
<div class="d-flex align-items-center gap-3 mb-2">
<div class="captcha-image" role="img" :aria-label="t('CAPTCHA.IMAGE_ALT')" v-html="captcha?.svg ?? ''"></div>
<a href="#" class="small" @click.prevent="reload">{{ t('CAPTCHA.NEW_IMAGE') }}</a>
</div>
<input id="captcha" v-model="input" type="text" maxlength="10" autocomplete="off" autocapitalize="off" spellcheck="false"
class="form-control" :class="{ 'is-invalid': error }">
<div v-if="error" class="invalid-feedback">{{ t(error) }}</div>
<div v-else class="form-text">{{ t('CAPTCHA.HELP') }}</div>
</div>
</template>
|
- Zeilen 30–37: ein neues CAPTCHA; die vorherige Eingabe wird gelöscht;
- Zeile 39: was das ELTERNELEMENT an dieser Komponente aufrufen kann, über eine Template-Referenz (siehe [LoginView.vue]). Ohne [defineExpose] stellt eine [<script setup>]-Komponente nichts bereit;
- Zeile 47: Das SVG-Bild, unverändert eingefügt: Es stammt von unserem Server (siehe Beispiel 17).
10.12.7. src/components/BookingDialog.vue
| <!--
=========================================================================
components/BookingDialog.vue - the dialog to book a slot
-------------------------------------------------------------------------
Same dialog as views/partials/booking.hbs of the HTML application
(and as the booking-dialog component of the Angular client): the
Bootstrap classes of a modal dialog, displayed "hard-coded" (show d-block).
The component does not talk to the server: it emits
- 'confirm' with the chosen patient (null for a patient who books
for themselves);
- 'close'.
It is the schedule page that decides what to do with it (ScheduleView.vue).
=========================================================================
-->
<script setup lang="ts">
import { onMounted, onUnmounted, ref, useTemplateRef } from 'vue';
import { useI18n } from 'vue-i18n';
import type { Person } from '../api/types';
import { label } from '../composables/useFormatting';
const props = defineProps<{
time: string; // "8:00 - 8:20"
clients: Person[]; // ADMIN / DOCTOR: die Patienten zur Auswahl
patient: string | null; // USER: Der Patient ist man selbst
submitting: boolean;
}>();
const emit = defineEmits<{ confirm: [clientId: number | null]; close: [] }>();
const { t } = useI18n();
const clientId = ref<number | null>(null);
const list = useTemplateRef<HTMLSelectElement>('list');
const confirmButton = useTemplateRef<HTMLButtonElement>('confirmButton');
function onEscape(e: KeyboardEvent): void {
if (e.key === 'Escape') {
emit('close');
}
}
onMounted(() => {
// der Fokus auf dem ersten nützlichen Element des Dialogs
(props.patient === null ? list.value : confirmButton.value)?.focus();
document.addEventListener('keydown', onEscape);
});
onUnmounted(() => document.removeEventListener('keydown', onEscape));
</script>
<template>
<Teleport to="body">
<div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true" aria-labelledby="booking-title"
@click.self="emit('close')">
<div class="modal-dialog modal-dialog-centered">
<form class="modal-content" @submit.prevent="emit('confirm', clientId)">
<div class="modal-header">
<h5 id="booking-title" class="modal-title">{{ t('BOOKING_DIALOG.TITLE') }}</h5>
<button type="button" class="btn-close" :aria-label="t('BOOKING_DIALOG.CLOSE_ARIA')" @click="emit('close')"></button>
</div>
<div class="modal-body">
<p>{{ t('BOOKING_DIALOG.SLOT', { time }) }}</p>
<!-- a patient books for themselves: no list (and the server
would ignore a possible clientId anyway) -->
<p v-if="patient !== null" class="mb-0">{{ t('BOOKING_DIALOG.PATIENT_LABEL') }}: <strong>{{ patient }}</strong></p>
<template v-else>
<label class="form-label" for="clientId">{{ t('BOOKING_DIALOG.PATIENT_LABEL') }}</label>
<select id="clientId" ref="list" v-model="clientId" class="form-select">
<option :value="null">{{ t('BOOKING_DIALOG.CHOOSE_PATIENT') }}</option>
<option v-for="c in clients" :key="c.id" :value="c.id">{{ label(c) }}</option>
</select>
</template>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-secondary" @click="emit('close')">{{ t('BOOKING_DIALOG.CANCEL') }}</button>
<button ref="confirmButton" type="submit" class="btn btn-primary" :disabled="submitting">{{ t('BOOKING_DIALOG.CONFIRM') }}</button>
</div>
</form>
</div>
</div>
</Teleport>
</template>
|
Das Fenster zur Terminbuchung. Es kommuniziert nicht mit dem Server: Es sendet entweder [confirm] mit dem ausgewählten Patienten oder [close]. Die Terminkalenderseite entscheidet, was damit geschieht.
- Zeilen 22–27: die Terminzeit und entweder die Liste der Patienten (ADMIN, DOCTOR) oder der Name des angemeldeten Patienten (USER);
- Zeilen 42–46: Beim Öffnen geht der Fokus an das erste zutreffende Element (die Patientenliste oder die Schaltfläche „Bestätigen“); die Esc-Taste schließt das Fenster;
- Zeile 56: ein echtes Formular: Die Eingabetaste bestätigt;
- Zeile 66: Ein Patient reserviert für sich selbst: keine Liste.
10.13. Die Seiten
10.13.1. src/views/LoginView.vue
| <!--
=========================================================================
views/LoginView.vue - the login page (/login)
-------------------------------------------------------------------------
Same page as views/login.hbs of the HTML application: login,
password, captcha, and a second button "Create a patient account" that checks
the SAME captcha before opening the account creation.
/login?login=jbernard: the login field is pre-filled (right after the
creation of an account).
/login?redirect=/doctors: after login, this page is opened
(set by the router guard) rather than the home page of the role.
=========================================================================
-->
<script setup lang="ts">
import { onMounted, reactive, ref, useTemplateRef } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { ApiError } from '../api/http-client';
import { rdvApi } from '../api/rdvmedecins.api';
import { useSessionStore } from '../stores/session';
import { useMessagesStore } from '../stores/messages';
import CaptchaField from '../components/CaptchaField.vue';
const { t } = useI18n();
const route = useRoute();
const router = useRouter();
const session = useSessionStore();
const messages = useMessagesStore();
const form = reactive({
login: typeof route.query.login === 'string' ? route.query.login.slice(0, 30) : '',
password: '',
captcha: '',
});
const captchaError = ref<string | undefined>(undefined);
const submitting = ref(false);
const captchaField = useTemplateRef<InstanceType<typeof CaptchaField>>('captchaField');
const loginField = useTemplateRef<HTMLInputElement>('loginField');
const passwordField = useTemplateRef<HTMLInputElement>('passwordField');
// der Fokus: auf dem Passwort, wenn der Login bereits ausgefüllt ist
onMounted(() => (form.login ? passwordField.value : loginField.value)?.focus());
// beide Buttons teilen sich diese Abfolge: Absenden, dann bei einem Fehler
// Fehlermeldung und ein NEUES Bild (jedes wird nur einmal verwendet)
async function attempt(action: () => Promise<void>): Promise<void> {
messages.clear();
captchaError.value = undefined;
submitting.value = true;
try {
await action();
} catch (e) {
messages.showApiError(e);
if (e instanceof ApiError) {
captchaError.value = e.fields.captcha;
}
await captchaField.value?.reload();
} finally {
submitting.value = false;
}
}
function logIn(): Promise<void> {
return attempt(async () => {
await session.logIn(form.login.trim(), form.password, captchaField.value?.captchaId() ?? '', form.captcha);
const redirect = route.query.redirect;
// nur ein INTERNER Pfad: niemals eine Weiterleitung auf eine andere Site
router.push(typeof redirect === 'string' && redirect.startsWith('/') && !redirect.startsWith('//') ? redirect : session.homePage);
});
}
function createAccount(): Promise<void> {
return attempt(async () => {
await rdvApi.registrationAccess(captchaField.value?.captchaId() ?? '', form.captcha);
router.push({ name: 'register' });
});
}
</script>
<template>
<div class="row justify-content-center">
<div class="col-sm-8 col-md-6 col-lg-5">
<div class="card p-4">
<h5 class="card-title mb-3">{{ t('LOGIN.TITLE') }}</h5>
<form @submit.prevent="logIn">
<div class="mb-3">
<label class="form-label" for="login">{{ t('LOGIN.LOGIN_LABEL') }}</label>
<input id="login" ref="loginField" v-model="form.login" type="text" class="form-control" autocomplete="username" required>
</div>
<div class="mb-3">
<label class="form-label" for="password">{{ t('LOGIN.PASSWORD_LABEL') }}</label>
<input id="password" ref="passwordField" v-model="form.password" type="password" class="form-control"
autocomplete="current-password" required>
</div>
<CaptchaField ref="captchaField" v-model="form.captcha" :error="captchaError" />
<!-- type="submit": Die Eingabetaste in einem Feld löst "Log in" aus -->
<button type="submit" class="btn btn-primary w-100" :disabled="submitting">{{ t('LOGIN.SUBMIT') }}</button>
<!-- type="button": this button does not submit the form (no
required check on login and password, useless here) -->
<button type="button" class="btn btn-outline-primary w-100 mt-3" :disabled="submitting" @click="createAccount">
{{ t('LOGIN.CREATE_ACCOUNT') }}
</button>
<div class="form-text text-center">{{ t('LOGIN.CREATE_ACCOUNT_HELP') }}</div>
</form>
<div class="text-muted small mt-3">
{{ t('LOGIN.DEMO_ACCOUNTS') }}
<ul class="mb-0 mt-1">
<li><code>admin</code> - {{ t('LOGIN.DEMO_ADMIN') }}</li>
<li><code>pelissier</code>, <code>tatou</code>, <code>dupont</code> - {{ t('LOGIN.DEMO_DOCTOR') }}</li>
<li><code>martin</code>, <code>durand</code>, <code>bistrou</code>, <code>german</code> - {{ t('LOGIN.DEMO_USER') }}</li>
</ul>
</div>
</div>
</div>
</div>
</template>
|
- Zeile 32: [/login?login=jbernard] füllt das Login-Feld vor (unmittelbar nach der Kontoerstellung);
- Zeile 38: eine Referenz auf die KOMPONENTE [CaptchaField]: Wir können aufrufen, was sie bereitstellt ([reload()], [captchaId()]). [InstanceType<typeof CaptchaField>] ist ihr Typ;
- Zeile 43: Der Fokus liegt auf dem Passwortfeld, wenn der Benutzername bereits ausgefüllt ist;
- Zeilen 47–62: Beide Schaltflächen folgen derselben Abfolge: Senden; bei Misserfolg erscheint eine Fehlermeldung, gegebenenfalls zusammen mit einem Fehler unter dem CAPTCHA-Feld, und ein NEUES Bild;
- Zeilen 64–71: die Anmeldung, gefolgt von der vor der Anmeldung angeforderten Seite (Parameter [redirect], vom Router gesetzt) oder der Startseite der Rolle. Es wird nur ein interner Pfad akzeptiert: Er muss mit [/] beginnen, aber nicht mit [//] ([//site.com/...] verweist auf eine ANDERE Website);
- Zeilen 73–78: „Patientenkonto erstellen“: Der Server prüft das CAPTCHA und stellt ein Token aus; anschließend öffnet sich die Seite zur Kontoerstellung;
- Zeile 105: [type="button"]: Diese Schaltfläche sendet das Formular nicht ab. In der HTML-Anwendung war dies eine zweite Schaltfläche, die dasselbe Formular an eine andere Adresse sendete ([formaction]).
10.13.2. src/views/ScheduleView.vue
Die Hauptseite. Wie in der HTML-Anwendung befindet sich ihr GESAMTER Zustand in der URL:
| /schedule choice of the doctor and the day
/schedule?doctorId=1&day=2026-10-05 the schedule
/schedule?doctorId=1&day=2026-10-05&book=7 + the booking dialog for slot 7
|
| <!--
=========================================================================
views/ScheduleView.vue - the schedule page (/schedule)
-------------------------------------------------------------------------
Three blocks, like views/schedule.hbs of the HTML application:
1. the choice of the doctor and of the day;
2. the schedule of that doctor on that day;
3. the dialog to book a slot.
As in the HTML application, ALL the state of the page is in its URL:
/schedule?doctorId=1&day=2026-10-05 the schedule
/schedule?doctorId=1&day=2026-10-05&book=7 + the booking dialog
The page can therefore be reloaded, bookmarked, and the browser's Back /
Forward buttons can be used. The page FOLLOWS its URL: a watch on the
query reloads the schedule; the user's actions, on the other hand, change
the URL (router.push).
What each user sees and can do is decided by the SERVER (fields
patient, mine, bookable, appointmentId of each slot): the page merely
displays it. A patient does not even receive the name of the other patients.
=========================================================================
-->
<script setup lang="ts">
import { computed, onMounted, reactive, ref, watch } from 'vue';
import { RouterLink, useRoute, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { ApiError } from '../api/http-client';
import { rdvApi } from '../api/rdvmedecins.api';
import type { Schedule, ScheduleSlot, Person } from '../api/types';
import { today, isValidDate, label, useFormatting } from '../composables/useFormatting';
import { useConfirmation } from '../composables/useConfirmation';
import { useSessionStore } from '../stores/session';
import { useMessagesStore } from '../stores/messages';
import BookingDialog from '../components/BookingDialog.vue';
const { t } = useI18n();
const route = useRoute();
const router = useRouter();
const session = useSessionStore();
const messages = useMessagesStore();
const { timeRange, longDate } = useFormatting();
const { confirm } = useConfirmation();
const doctors = ref<Person[]>([]);
const clients = ref<Person[]>([]); // ADMIN / DOCTOR: für den Buchungsdialog
const schedule = ref<Schedule | null>(null);
const loading = ref(false);
const submitting = ref(false);
// die Werte des Formulars "Arzt + Tag", aus der URL kopiert
const choice = reactive<{ doctorId: number | null; day: string }>({ doctorId: null, day: today() });
// "3" -> 3 ; "", "abc", "-2", fehlend -> null
function positiveInteger(value: unknown): number | null {
const n = Number(value);
return typeof value === 'string' && value !== '' && Number.isInteger(n) && n > 0 ? n : null;
}
// der angezeigte Terminkalender ohne Buchungsdialog: die Query "back"
const scheduleQuery = computed(() => ({ doctorId: String(choice.doctorId ?? ''), day: choice.day }));
// der Slot, dessen Buchungsdialog geöffnet ist (?book=7),
// nur wenn er von diesem Benutzer buchbar ist
const slotToBook = computed<ScheduleSlot | null>(() => {
const id = positiveInteger(route.query.book);
return schedule.value?.slots.find((s) => s.id === id && s.bookable) ?? null;
});
// -------------------------------------------------------------------------
// Laden
// -------------------------------------------------------------------------
onMounted(async () => {
try {
doctors.value = await rdvApi.list('doctors');
// die Patientenliste: nur für diejenigen, die sie lesen dürfen
if (session.isManager) {
clients.value = await rdvApi.list('clients');
}
} catch (e) {
messages.showApiError(e);
}
});
// der Terminkalender folgt der URL (Arzt und Tag)
watch(() => [route.query.doctorId, route.query.day], loadSchedule, { immediate: true });
async function loadSchedule(): Promise<void> {
// der Tag: der in der URL, falls gültig, andernfalls heute
const rawDay = route.query.day;
choice.day = today();
if (rawDay !== undefined) {
if (!isValidDate(rawDay)) {
schedule.value = null;
messages.showError('ERRORS.INVALID_DATE');
return;
}
choice.day = rawDay;
}
// der Arzt: der in der URL; ohne Arzt sieht ein DOCTOR SEINEN Terminkalender
// (der Server findet ihn anhand des Tokens)
choice.doctorId = positiveInteger(route.query.doctorId);
if (choice.doctorId === null && session.role !== 'DOCTOR') {
schedule.value = null;
return;
}
loading.value = true;
try {
schedule.value = await rdvApi.schedule(choice.doctorId, choice.day);
choice.doctorId = schedule.value.doctor.id;
} catch (e) {
schedule.value = null;
messages.showApiError(e);
} finally {
loading.value = false;
}
}
// -------------------------------------------------------------------------
// Aktionen
// -------------------------------------------------------------------------
// "View schedule": Die URL wird geändert, der Terminkalender folgt (watch oben)
function viewSchedule(): void {
router.push({ query: scheduleQuery.value });
}
function closeBooking(): void {
router.push({ query: scheduleQuery.value });
}
async function book(clientId: number | null): Promise<void> {
const slot = slotToBook.value;
if (slot === null) {
return;
}
submitting.value = true;
try {
await rdvApi.book(choice.day, slot.id, session.isManager ? clientId : null);
messages.flash('success', 'SCHEDULE.BOOKED');
} catch (e) {
if (e instanceof ApiError && e.key === 'ERRORS.CHOOSE_PATIENT') {
// kein Patient gewählt: Der Dialog bleibt geöffnet
messages.showError(e.key);
return; // (finally wird trotzdem ausgeführt)
}
if (!(e instanceof ApiError)) {
throw e;
}
// Slot zwischenzeitlich belegt, Patient hat bereits einen Termin ...:
// Die Meldung wird im Terminkalender angezeigt, Dialog geschlossen
messages.flash('error', e.key, e.params);
} finally {
submitting.value = false;
}
await router.push({ query: scheduleQuery.value });
await loadSchedule(); // der Server ist die Referenz: Der Terminkalender wird neu gelesen
}
async function cancel(s: ScheduleSlot): Promise<void> {
if (s.appointmentId === null || !(await confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
try {
await rdvApi.cancelAppointment(s.appointmentId);
messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
messages.showApiError(e);
}
await loadSchedule();
}
</script>
<template>
<!-- 1. die Wahl des Arztes und des Tages -->
<form class="card p-3 mb-3" @submit.prevent="viewSchedule">
<div class="row g-2 align-items-end">
<div class="col-sm-5">
<label class="form-label" for="doctorId">{{ t('DOCTOR_DAY_PICKER.DOCTOR_LABEL') }}</label>
<select id="doctorId" v-model="choice.doctorId" class="form-select" required>
<option :value="null">{{ t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR') }}</option>
<option v-for="d in doctors" :key="d.id" :value="d.id">{{ label(d) }}</option>
</select>
</div>
<div class="col-sm-4">
<label class="form-label" for="day">{{ t('DOCTOR_DAY_PICKER.DAY_LABEL') }}</label>
<input id="day" v-model="choice.day" type="date" class="form-control" required>
</div>
<div class="col-sm-3">
<button type="submit" class="btn btn-primary w-100">{{ t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE') }}</button>
</div>
</div>
</form>
<!-- Patient mit bereits bevorstehendem Termin: warum es keinen Button "Book" gibt -->
<div v-if="schedule?.info" class="alert alert-info">
{{ t(schedule.info) }} <RouterLink to="/my-area" class="alert-link">{{ t('APP.MENU_MY_AREA') }}</RouterLink>
</div>
<!-- 2. der Terminkalender -->
<p v-if="loading && !schedule" class="text-muted">{{ t('APP.LOADING') }}</p>
<div v-else-if="schedule" class="card p-3">
<h5>{{ t('SCHEDULE.TITLE_PREFIX') }} {{ longDate(schedule.day) }} - {{ label(schedule.doctor) }}</h5>
<table v-if="schedule.slots.length > 0" 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="s in schedule.slots" :key="s.id" :class="{ 'free-slot': s.bookable }">
<td>{{ timeRange(s) }}</td>
<td>
<span v-if="s.free" class="badge text-bg-success">{{ t('SCHEDULE.FREE') }}</span>
<span v-else-if="s.patient" class="badge" :class="s.mine ? 'text-bg-primary' : 'text-bg-secondary'">{{ label(s.patient) }}</span>
<span v-else class="badge text-bg-secondary">{{ t('SCHEDULE.BOOKED_BY_OTHER') }}</span>
</td>
<td class="text-end">
<!-- "Book" is a LINK: it adds ?book=... to the URL, which
opens the booking dialog -->
<RouterLink v-if="s.bookable" class="btn btn-sm btn-outline-success" :to="{ query: { ...scheduleQuery, book: s.id } }">
{{ t('SCHEDULE.BOOK') }}
</RouterLink>
<button v-if="s.appointmentId !== null" type="button" class="btn btn-sm btn-outline-danger" @click="cancel(s)">
{{ t('SCHEDULE.CANCEL_APPOINTMENT') }}
</button>
</td>
</tr>
</tbody>
</table>
<p v-else class="text-muted mb-0">{{ t('SCHEDULE.NO_SLOTS') }}</p>
</div>
<p v-else class="text-muted">{{ t('SCHEDULE.EMPTY_STATE') }}</p>
<!-- 3. der Buchungsdialog, nur wenn die URL &book=... enthält -->
<BookingDialog
v-if="slotToBook"
:time="timeRange(slotToBook)"
:clients="clients"
:patient="session.isPatient ? (session.user?.name ?? '') : null"
:submitting="submitting"
@confirm="book"
@close="closeBooking"
/>
</template>
|
Seitendaten:
- Zeilen 44–48: die Listen, der angezeigte Terminkalender sowie die Lade- und Sendeindikatoren;
- Zeile 51: die Werte des Formulars „Arzt + Tag“. Sie werden AUS der URL kopiert; der Benutzer kann sie ändern, ohne dass dies eine Wirkung hat, bis er auf „Terminkalender anzeigen“ klickt;
- Zeile 60: die [query] für den angezeigten Terminkalender, ohne Buchungsfenster;
- Zeilen 64–67: das Zeitfenster, für das das Fenster geöffnet ist: [?book=...], wenn es existiert UND von diesem Benutzer buchbar ist. Eine manuell erstellte URL ([book=] auf einem belegten Zeitfenster) öffnet daher kein Buchungsfenster.
Laden:
- Zeilen 72–82: Die Liste der Ärzte ist für alle sichtbar, die Liste der Patienten nur für die dazu Berechtigten;
- Zeile 85: Die Seite FOLGT der URL. [immediate]: Der Terminkalender wird geladen, sobald die Seite angezeigt wird (eine als Lesezeichen gespeicherte URL, ein F5); danach jedes Mal, wenn sich der Arzt oder das Datum in der URL ändert (durch Klick auf „Terminkalender anzeigen“ oder die Schaltflächen Zurück/Weiter). Eine Änderung von [book] allein lädt den Terminkalender nicht neu: Sie öffnet oder schließt lediglich das Fenster (siehe [slotToBook]);
- Zeilen 87–116: der Tag aus der URL (standardmäßig heute; ein Fehler tritt auf, wenn er nicht existiert); der Arzt aus der URL; ist kein Arzt angegeben, sieht ein angemeldeter Arzt SEINEN Terminkalender (der Server ermittelt ihn anhand des Tokens), und der vom Server zurückgegebene Arzt wird dann in das Formular kopiert.
Aktionen:
- Zeilen 123–125: „Terminkalender anzeigen“ lädt selbst nichts: Es ändert die URL, und der Terminkalender aktualisiert sich entsprechend;
- Zeilen 131–157: der Termin:
- Ist kein Patient ausgewählt: Der Server verwendet den aus dem Token;
- kein Patient ausgewählt (ADMIN, DOCTOR): Das Fenster bleibt offen und zeigt die Meldung an;
- Erfolg oder eine andere Ablehnung (Zeitfenster inzwischen vergeben, Patient hat bereits einen Termin): eine Pop-up-Meldung, dann die URL ohne [book] (das Fenster schließt sich), gefolgt vom Neuladen des Terminkalenders: Die Version des Servers ist maßgeblich;
- Zeilen 159–170: Stornierung nach Bestätigung. Der Server liefert [appointmentId] für die Zeitfenster, die der Benutzer stornieren kann: für ADMIN oder DOCTOR alle; für einen Patienten die eigenen (die HTML-Anwendung erlaubte dies nur über „Mein Bereich“; die API erlaubt es auch im Terminkalender).
Das Template:
- Zeile 175: Auswahl des Arztes und des Tages;
- Zeile 195: ein Patient, der bereits einen bevorstehenden Termin hat: Warum es keine Schaltfläche „Buchen“ gibt;
- Zeile 202: der Tag, in der aktuellen Sprache formatiert;
- Zeilen 216 und 217: der Name des Patienten, falls er gesendet wurde; andernfalls „Belegt“;
- Zeile 222: „Buchen“ ist ein LINK: Er fügt [book=...] der URL hinzu. Die Zurück-Schaltfläche des Browsers schließt daher das Fenster;
- Zeilen 237–244: das Fenster, wenn es von der URL angefordert wird.
10.13.3. src/views/persons.config.ts
Die Seiten zur Verwaltung von Ärzten und Clients sind gemeinsam. Was sie unterscheidet:
| // =========================================================================
// views/persons.config.ts - Ärzte oder Clients?
// -------------------------------------------------------------------------
// Die Seiten zur Verwaltung von Ärzten und Clients sind IDENTISCH: dieselbe
// Liste, dasselbe Formular. Wie in der HTML-Anwendung (abstrakte Klasse
// PersonsController) werden sie EINMAL geschrieben (PersonsView.vue,
// PersonFormView.vue); nur die Adresse der API und die
// Schlüssel der Beschriftungen ändern sich, hier beschrieben. Der Router gibt den Typ in der
// Eigenschaft meta jeder Route an (siehe router.ts).
// =========================================================================
import type { PersonType } from '../api/rdvmedecins.api';
export interface PersonKeys {
title: string; // "Doctors"
add: string; // "Add a doctor"
edit: string; // "Edit a doctor"
empty: string; // "No doctors."
confirmDelete: string;
added: string; // "Doctor {name} has been added (login: {login})."
edited: string;
deleted: string;
}
export const PERSON_KEYS: Record<PersonType, PersonKeys> = {
doctors: {
title: 'DOCTORS.TITLE',
add: 'DOCTORS.ADD',
edit: 'DOCTORS.EDIT',
empty: 'DOCTORS.EMPTY',
confirmDelete: 'DOCTORS.DELETE_CONFIRM',
added: 'DOCTORS.ADDED',
edited: 'DOCTORS.UPDATED',
deleted: 'DOCTORS.DELETED',
},
clients: {
title: 'CLIENTS.TITLE',
add: 'CLIENTS.ADD',
edit: 'CLIENTS.EDIT',
empty: 'CLIENTS.EMPTY',
confirmDelete: 'CLIENTS.DELETE_CONFIRM',
added: 'CLIENTS.ADDED',
edited: 'CLIENTS.UPDATED',
deleted: 'CLIENTS.DELETED',
},
};
// {name} und {login} der Meldungen "hinzugefügt / aktualisiert / gelöscht"
export function messageParams(p: { firstName: string; lastName: string; login?: string }): Record<string, string> {
return { name: `${p.firstName} ${p.lastName}`, login: p.login ?? '' };
}
|
- Zeile 25: die Schlüssel für die typspezifischen Beschriftungen, wie in den Controllern [DoctorsController] und [ClientsController] der HTML-Anwendung;
- Zeilen 49–51: die Parameter [{name}] und [{login}] für die Meldungen „hinzugefügt/geändert/gelöscht“.
10.13.4. src/views/PersonsView.vue
| <!--
=========================================================================
views/PersonsView.vue - the list of doctors OR of clients (ADMIN)
-------------------------------------------------------------------------
A single page for both: the type ('doctors' or 'clients') is in
the metadata of the route (route.meta.type, see router.ts), the labels
specific to each in persons.config.ts. Equivalent of
views/persons/list.hbs of the HTML application.
=========================================================================
-->
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue';
import { RouterLink, useRoute } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { rdvApi, type PersonType } from '../api/rdvmedecins.api';
import type { Person } from '../api/types';
import { useConfirmation } from '../composables/useConfirmation';
import { useMessagesStore } from '../stores/messages';
import { PERSON_KEYS, messageParams } from './persons.config';
const { t } = useI18n();
const route = useRoute();
const messages = useMessagesStore();
const { confirm } = useConfirmation();
const type = route.meta.type as PersonType;
const keys = PERSON_KEYS[type];
const persons = ref<Person[] | null>(null); // null: noch nicht geladen
const empty = computed(() => persons.value !== null && persons.value.length === 0);
async function load(): Promise<void> {
try {
persons.value = await rdvApi.list(type);
} catch (e) {
messages.showApiError(e);
}
}
async function remove(p: Person): Promise<void> {
if (!(await confirm(keys.confirmDelete))) {
return;
}
try {
await rdvApi.remove(type, p.id);
messages.showSuccess(keys.deleted, messageParams(p));
} catch (e) {
// ein Arzt, der noch Termine hat: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
messages.showApiError(e);
}
await load();
}
onMounted(load);
</script>
<template>
<div class="d-flex justify-content-between align-items-center mb-3">
<h4 class="mb-0">{{ t(keys.title) }}</h4>
<RouterLink class="btn btn-primary" :to="`/${type}/add`">{{ t(keys.add) }}</RouterLink>
</div>
<div class="card p-3">
<p v-if="persons === null" class="text-muted mb-0">{{ t('APP.LOADING') }}</p>
<p v-else-if="empty" class="text-muted mb-0">{{ t(keys.empty) }}</p>
<table v-else class="table table-hover align-middle mb-0">
<thead>
<tr>
<th>{{ t('PERSONS.COLUMN_TITLE') }}</th>
<th>{{ t('PERSONS.COLUMN_FIRSTNAME') }}</th>
<th>{{ t('PERSONS.COLUMN_LASTNAME') }}</th>
<th>{{ t('PERSONS.COLUMN_LOGIN') }}</th>
<th></th>
</tr>
</thead>
<tbody>
<tr v-for="p in persons" :key="p.id">
<td>{{ p.title }}</td>
<td>{{ p.firstName }}</td>
<td>{{ p.lastName }}</td>
<td><code>{{ p.login }}</code></td>
<td class="text-end">
<div class="d-inline-flex gap-2">
<RouterLink class="btn btn-sm btn-outline-primary" :to="`/${type}/${p.id}/edit`">{{ t('PERSONS.EDIT') }}</RouterLink>
<button type="button" class="btn btn-sm btn-outline-danger" @click="remove(p)">{{ t('PERSONS.DELETE') }}</button>
</div>
</td>
</tr>
</tbody>
</table>
</div>
</template>
|
- Zeile 26: der Personentyp, aus den Metadaten der Route gelesen. Er ändert sich während der Lebensdauer der Komponente nicht: Beim Wechsel von [/doctors] zu [/clients] erzeugt der Schlüssel [:key] von [<RouterView>] die Seite neu;
- Zeile 28: [null] , solange die Liste nicht geladen wurde: So unterscheidet man „wird geladen“ von „leere Liste“;
- Zeilen 39–51: Bestätigung, Löschung, Meldung und Neuladen der Liste. Hat ein Arzt noch Termine: Der Server liefert eine 409-Antwort, und die Meldung wird am unteren Seitenrand angezeigt.
| <!--
=========================================================================
views/PersonFormView.vue - creation OR update of a doctor
or of a client (ADMIN)
-------------------------------------------------------------------------
/doctors/add -> creation (no id prop)
/doctors/3/edit -> update (prop id = 3, see router.ts)
(and the same addresses under /clients). Equivalent of
views/persons/form.hbs of the HTML application.
No rule is checked here: the server validates everything, and its errors
are displayed under the fields (see composables/useForm.ts).
The VERSION read with the record goes back with the update: if another
ADMIN has changed it in the meantime, the server answers 409 CONCURRENT_UPDATE.
=========================================================================
-->
<script setup lang="ts">
import { computed, onMounted, reactive } from 'vue';
import { RouterLink, useRoute, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { ApiError } from '../api/http-client';
import { rdvApi, type PersonType } from '../api/rdvmedecins.api';
import type { PersonData } from '../api/types';
import { useForm } from '../composables/useForm';
import { useMessagesStore } from '../stores/messages';
import PersonFields from '../components/PersonFields.vue';
import InputField from '../components/InputField.vue';
import { PERSON_KEYS, messageParams } from './persons.config';
const props = defineProps<{ id?: number }>();
const { t } = useI18n();
const route = useRoute();
const router = useRouter();
const messages = useMessagesStore();
const { errors, params, submitting, submit } = useForm();
const type = route.meta.type as PersonType;
const keys = PERSON_KEYS[type];
const creating = computed(() => props.id === undefined);
const form = reactive<PersonData>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', version: undefined });
// Aktualisierung: Der Datensatz wird gelesen (einschließlich seiner Version)
onMounted(async () => {
if (props.id === undefined) {
return;
}
try {
const p = await rdvApi.read(type, props.id);
Object.assign(form, { title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', version: p.version });
} catch (e) {
// nicht existierender Datensatz (zwischenzeitlich gelöscht ...): zurück zur Liste
if (e instanceof ApiError) {
messages.flash('error', e.key, e.params);
router.push(`/${type}`);
return;
}
throw e;
}
});
async function save(): Promise<void> {
const succeeded = await submit(async () => {
const p = props.id === undefined ? await rdvApi.add(type, form) : await rdvApi.edit(type, props.id, form);
messages.flash('success', creating.value ? keys.added : keys.edited, messageParams(p));
});
if (succeeded) {
router.push(`/${type}`);
} else if (messages.error?.key === 'ERRORS.DOCTOR_NOT_FOUND' || messages.error?.key === 'ERRORS.PATIENT_NOT_FOUND') {
// zwischenzeitlich von einem anderen ADMIN gelöscht: zurück zur Liste
messages.flash('error', messages.error.key);
router.push(`/${type}`);
}
}
</script>
<template>
<div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<div class="card p-4">
<h5 class="card-title mb-3">{{ t(creating ? keys.add : keys.edit) }}</h5>
<!-- novalidate: Es ist der SERVER, der validiert (er ist die Referenz) -->
<form novalidate @submit.prevent="save">
<PersonFields v-model:title="form.title" v-model:firstName="form.firstName" v-model:lastName="form.lastName" :errors="errors" />
<h6 class="mt-4 text-muted">{{ t('PERSONS.ACCOUNT_SECTION') }}</h6>
<InputField v-model="form.login" class="mb-3" id="login" label="PERSONS.LOGIN_LABEL" :maxlength="30"
:error="errors.login" :help="creating ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT'" />
<!-- niemals vorausgefüllt: Das Passwort kommt nie vom Server zurück -->
<InputField v-model="form.password" class="mb-4" id="password" type="password" label="PERSONS.PASSWORD_LABEL"
:maxlength="72" autocomplete="new-password" :error="errors.password" :params="params"
:help="creating ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'" />
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" :disabled="submitting">{{ t('PERSONS.SAVE') }}</button>
<RouterLink class="btn btn-secondary" :to="`/${type}`">{{ t('PERSONS.BACK') }}</RouterLink>
</div>
</form>
</div>
</div>
</div>
</template>
|
- Zeile 30: Erstellung ohne [id], Änderung mit ihr (die Eigenschaft stammt aus der Route; siehe [router.ts]);
- Zeile 36: Formularfehler (siehe [useForm.ts]);
- Zeilen 45–61: Bei einer Änderung wird der Datensatz gelesen, einschließlich der Version. Existiert er nicht (zwischenzeitlich gelöscht), geht es mit einer Meldung zurück zur Liste;
- Zeilen 63–75: POST oder PUT; bei Erfolg wird eine Meldung angezeigt und zur Liste zurückgekehrt. Schlägt die Operation fehl, hat [useForm] die Fehler bereits angezeigt; wurde ein Datensatz zwischenzeitlich gelöscht, kehrt das Programm zur Liste zurück;
- Zeile 84: [novalidate]: Der Server validiert;
- Zeile 85: die drei benannten [v-model]-Direktiven;
- Zeile 91: Das Passwort wird nie vorausgefüllt: Der Server gibt es nie zurück.
10.13.6. src/views/RegisterView.vue
| <!--
=========================================================================
views/RegisterView.vue - "Create a patient account" (/register, public)
-------------------------------------------------------------------------
One only gets here after typing the captcha of the login page
(button "Create a patient account"): the server has then issued a
pass, which the route guard has checked (see router.ts).
Same fields as the ADMIN's form, but the login and the password
are required, with confirmation. Equivalent of
views/account/registration.hbs of the HTML application.
=========================================================================
-->
<script setup lang="ts">
import { reactive } from 'vue';
import { RouterLink, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { rdvApi } from '../api/rdvmedecins.api';
import type { Registration } from '../api/types';
import { useForm } from '../composables/useForm';
import { useMessagesStore } from '../stores/messages';
import PersonFields from '../components/PersonFields.vue';
import InputField from '../components/InputField.vue';
const { t } = useI18n();
const router = useRouter();
const messages = useMessagesStore();
const { errors, params, submitting, submit } = useForm();
// Mindestlänge eines von einem Patienten gewählten Passworts: derselbe Wert
// wie beim Server (der bei dem Fehler PASSWORD_TOO_SHORT auch {min} zurückgibt)
const PASSWORD_MIN = '6';
const form = reactive<Registration>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' });
async function create(): Promise<void> {
let login = '';
const succeeded = await submit(async () => {
login = (await rdvApi.register(form)).login;
});
if (succeeded) {
// zurück zur Login-Seite, Login vorausgefüllt
messages.flash('success', 'REGISTRATION.DONE', { login });
router.push({ name: 'login', query: { login } });
} else if (messages.error?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
// Pass abgelaufen (15 Minuten): zurück zum CAPTCHA
messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
router.push({ name: 'login' });
}
}
</script>
<template>
<div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<div class="card p-4">
<h5 class="card-title mb-1">{{ t('REGISTRATION.TITLE') }}</h5>
<p class="text-muted small mb-3">{{ t('REGISTRATION.INTRO') }}</p>
<form novalidate @submit.prevent="create">
<PersonFields v-model:title="form.title" v-model:firstName="form.firstName" v-model:lastName="form.lastName" :errors="errors" />
<h6 class="mt-4 text-muted">{{ t('PERSONS.ACCOUNT_SECTION') }}</h6>
<InputField v-model="form.login" class="mb-3" id="login" label="PERSONS.LOGIN_LABEL" :maxlength="30"
autocomplete="username" required :error="errors.login" help="REGISTRATION.LOGIN_HELP" />
<div class="row g-3 mb-3">
<InputField v-model="form.password" class="col-sm-6" id="password" type="password" label="PERSONS.PASSWORD_LABEL"
:maxlength="72" autocomplete="new-password" required :error="errors.password"
:params="{ min: PASSWORD_MIN, ...params }" help="REGISTRATION.PASSWORD_HELP" />
<InputField v-model="form.confirmation" class="col-sm-6" id="confirmation" type="password"
label="ACCOUNT.CONFIRMATION_LABEL" :maxlength="72" autocomplete="new-password" required
:error="errors.confirmation" />
</div>
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" :disabled="submitting">{{ t('REGISTRATION.SUBMIT') }}</button>
<RouterLink class="btn btn-secondary" to="/login">{{ t('REGISTRATION.BACK_TO_LOGIN') }}</RouterLink>
</div>
</form>
</div>
</div>
</div>
</template>
|
- Zeile 31: die Mindestlänge des Passworts für die Hilfemeldung (der Server liefert sie zusammen mit dem Fehler auch in [params] zurück);
- Zeilen 35–49: Kontoerstellung, gefolgt von der Anmeldeseite mit vorausgefülltem Benutzernamen. Ist das Token abgelaufen (15 Minuten), antwortet der Server mit einem 403-Fehler: Zurück zur Anmeldeseite, um ein neues CAPTCHA zu lösen;
- Zeile 67: die Meldungsparameter für das Feld; [...params] (der Spread-Operator) kopiert die vom Server zurückgegebenen.
Der Zugriff auf diese Seite wird durch den Guard [beforeEnter] ihrer Route kontrolliert (siehe [router.ts]).
10.13.7. src/views/PatientAreaView.vue
| <!--
=========================================================================
views/PatientAreaView.vue - "My area" (/my-area, USER role)
-------------------------------------------------------------------------
The home page of the patient, right after login:
- two options: [Manage my account] and [View a schedule];
- their upcoming appointment, if they have one, with the means to cancel it.
Equivalent of views/patient/area.hbs of the HTML application.
=========================================================================
-->
<script setup lang="ts">
import { onMounted, ref } from 'vue';
import { RouterLink } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { rdvApi } from '../api/rdvmedecins.api';
import type { MyArea } from '../api/types';
import { useFormatting } from '../composables/useFormatting';
import { useConfirmation } from '../composables/useConfirmation';
import { useMessagesStore } from '../stores/messages';
const { t } = useI18n();
const messages = useMessagesStore();
const { label, timeRange, longDate } = useFormatting();
const { confirm } = useConfirmation();
const area = ref<MyArea | null>(null);
async function load(): Promise<void> {
try {
area.value = await rdvApi.myArea();
} catch (e) {
messages.showApiError(e);
}
}
async function cancel(appointmentId: number): Promise<void> {
if (!(await confirm('SCHEDULE.CANCEL_CONFIRM'))) {
return;
}
try {
await rdvApi.cancelAppointment(appointmentId);
messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
messages.showApiError(e);
}
await load();
}
onMounted(load);
</script>
<template>
<template v-if="area">
<h4 class="mb-3">{{ t('AREA.HELLO', { name: label(area.patient) }) }}</h4>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<RouterLink class="card p-4 h-100 text-decoration-none option-card" to="/my-account">
<h5 class="mb-1">{{ t('AREA.MANAGE_ACCOUNT') }}</h5>
<span class="text-muted">{{ t('AREA.MANAGE_ACCOUNT_HELP') }}</span>
</RouterLink>
</div>
<div class="col-sm-6">
<RouterLink class="card p-4 h-100 text-decoration-none option-card" to="/schedule">
<h5 class="mb-1">{{ t('AREA.VIEW_SCHEDULE') }}</h5>
<span class="text-muted">{{ t('AREA.VIEW_SCHEDULE_HELP') }}</span>
</RouterLink>
</div>
</div>
<div class="card p-3">
<h5>{{ t('AREA.MY_APPOINTMENT') }}</h5>
<!-- normally only one (rule "one upcoming appointment at a time"),
but the page can display several -->
<div
v-for="(a, i) in area.appointments"
:key="a.id"
class="d-flex flex-wrap justify-content-between align-items-center gap-2 py-2"
:class="{ 'border-bottom': i < area.appointments.length - 1 }"
>
<div>
<div class="fw-semibold">{{ longDate(a.day) }}, {{ timeRange(a.slot) }}</div>
<div class="text-muted">
{{ label(a.doctor) }} -
<!-- der Terminkalender des Arztes an diesem Tag: Der Patient sieht darin seinen Namen -->
<RouterLink :to="{ path: '/schedule', query: { doctorId: a.doctor.id, day: a.day } }">{{ t('AREA.SEE_IN_SCHEDULE') }}</RouterLink>
</div>
</div>
<button type="button" class="btn btn-outline-danger" @click="cancel(a.id)">{{ t('AREA.CANCEL_APPOINTMENT') }}</button>
</div>
<p v-if="area.appointments.length === 0" class="text-muted mb-0">{{ t('AREA.NO_APPOINTMENT') }}</p>
</div>
</template>
<p v-else class="text-muted">{{ t('APP.LOADING') }}</p>
</template>
|
- Zeilen 36–47: Der Patient storniert SEINEN Termin (der Server würde den eines anderen ablehnen);
- Zeile 57: eine ganze Karte ist ein Link;
- Zeile 75: normalerweise nur ein Termin (die Regel „ein bevorstehender Termin zur Zeit“), die Seite kann aber mehrere anzeigen;
- Zeile 85: der Terminkalender des Arztes für diesen Tag, in dem der Patient seinen Namen sieht.
10.13.8. src/views/MyAccountView.vue
| <!--
=========================================================================
views/MyAccountView.vue - "Manage my account" (/my-account, USER role)
-------------------------------------------------------------------------
Two independent forms, like views/patient/account.hbs:
1. the update (identity, login, optional new password);
2. the deletion of the account - which also cancels its appointments.
Both require the CURRENT password (checked by the server).
=========================================================================
-->
<script setup lang="ts">
import { onMounted, reactive, ref } from 'vue';
import { RouterLink, useRouter } from 'vue-router';
import { useI18n } from 'vue-i18n';
import { rdvApi } from '../api/rdvmedecins.api';
import type { MyAccountUpdate } from '../api/types';
import { useForm } from '../composables/useForm';
import { useConfirmation } from '../composables/useConfirmation';
import { useSessionStore } from '../stores/session';
import { useMessagesStore } from '../stores/messages';
import PersonFields from '../components/PersonFields.vue';
import InputField from '../components/InputField.vue';
const { t } = useI18n();
const router = useRouter();
const session = useSessionStore();
const messages = useMessagesStore();
const { confirm } = useConfirmation();
// zwei Formulare, daher zwei Fehlersätze
const update = useForm();
const deletion = useForm();
const form = reactive<MyAccountUpdate>({
title: 'Mr',
firstName: '',
lastName: '',
login: '',
password: '',
confirmation: '',
currentPassword: '',
version: 0,
});
const deletePassword = ref('');
onMounted(async () => {
try {
Object.assign(form, await rdvApi.myAccount());
} catch (e) {
messages.showApiError(e);
}
});
async function save(): Promise<void> {
const succeeded = await update.submit(async () => {
// der Server hat ein NEUES Token ausgestellt (Name, Login): Die Navigationsleiste
// muss folgen
session.update(await rdvApi.editMyAccount(form));
messages.flash('success', 'MY_ACCOUNT.UPDATED');
});
// nach dem Absenden bleibt niemals ein Passwort in den Feldern
form.currentPassword = '';
if (succeeded) {
router.push('/my-area');
}
}
async function remove(): Promise<void> {
if (!(await confirm('MY_ACCOUNT.DELETE_CONFIRM'))) {
return;
}
const succeeded = await deletion.submit(async () => {
await rdvApi.deleteMyAccount(deletePassword.value);
});
deletePassword.value = '';
if (succeeded) {
session.forget(); // der Server hat das Token-Cookie gelöscht
messages.flash('success', 'MY_ACCOUNT.DELETED');
router.push({ name: 'login' });
}
}
</script>
<template>
<div class="row justify-content-center">
<div class="col-md-8 col-lg-6">
<!-- 1. Aktualisierung -->
<div class="card p-4 mb-4">
<h5 class="card-title mb-3">{{ t('MY_ACCOUNT.TITLE') }}</h5>
<form novalidate @submit.prevent="save">
<PersonFields v-model:title="form.title" v-model:firstName="form.firstName" v-model:lastName="form.lastName" :errors="update.errors.value" />
<h6 class="mt-4 text-muted">{{ t('PERSONS.ACCOUNT_SECTION') }}</h6>
<InputField v-model="form.login" class="mb-3" id="login" label="PERSONS.LOGIN_LABEL" :maxlength="30"
autocomplete="username" required :error="update.errors.value.login" />
<div class="row g-3 mb-3">
<InputField v-model="form.password" class="col-sm-6" id="password" type="password" label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
:maxlength="72" autocomplete="new-password" :error="update.errors.value.password"
:params="update.params.value" help="PERSONS.PASSWORD_HELP_EDIT" />
<InputField v-model="form.confirmation" class="col-sm-6" id="confirmation" type="password"
label="ACCOUNT.CONFIRMATION_LABEL" :maxlength="72" autocomplete="new-password"
:error="update.errors.value.confirmation" />
</div>
<InputField v-model="form.currentPassword" class="mb-4" id="currentPassword" type="password"
label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL" :maxlength="72" autocomplete="current-password" required
:error="update.errors.value.currentPassword" help="MY_ACCOUNT.CURRENT_PASSWORD_HELP" />
<div class="d-flex gap-2">
<button type="submit" class="btn btn-primary" :disabled="update.submitting.value">{{ t('PERSONS.SAVE') }}</button>
<RouterLink class="btn btn-secondary" to="/my-area">{{ t('MY_ACCOUNT.BACK') }}</RouterLink>
</div>
</form>
</div>
<!-- 2. Löschung -->
<div class="card p-4 border-danger">
<h5 class="card-title text-danger mb-1">{{ t('MY_ACCOUNT.DELETE_TITLE') }}</h5>
<p class="text-muted small">{{ t('MY_ACCOUNT.DELETE_HELP') }}</p>
<form class="d-flex flex-wrap gap-2 align-items-end" novalidate @submit.prevent="remove">
<InputField v-model="deletePassword" class="flex-grow-1" id="deletePassword" type="password"
label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL" :maxlength="72" autocomplete="current-password" required
:error="deletion.errors.value.currentPassword" />
<button type="submit" class="btn btn-danger" :disabled="deletion.submitting.value">{{ t('MY_ACCOUNT.DELETE_SUBMIT') }}</button>
</form>
</div>
</div>
</div>
</template>
|
- Zeilen 30–31: zwei Formulare, also zwei Fehlersätze: Ein Composable kann beliebig oft aufgerufen werden, und jeder Aufruf hat seinen eigenen Zustand;
- Zeile 47: Die gelesenen Werte werden in das Formular kopiert, einschließlich der Version;
- Zeilen 53–65: Der Server hat ein neues Token ausgestellt (Name und Login können sich geändert haben); er liefert den durch dieses Token beschriebenen Benutzer zurück, und die Sitzung wird aktualisiert: Die Navigationsleiste zieht nach. Das aktuelle Passwort wird nach jedem Senden gelöscht;
- Zeilen 67–80: Bestätigung, Löschung; der Server hat das Token-Cookie gelöscht: Der Benutzer wird vergessen und zur Anmeldeseite umgeleitet;
- Zeile 90: [update] ist ein gewöhnliches Objekt, das [ref]s ENTHÄLT: Im Template müssen Sie [.value] schreiben (siehe Beispiel 11).
10.13.9. src/views/ErrorView.vue
| <!--
views/ErrorView.vue - the error page: 404 (unknown address) or 403
(insufficient role, see the router guard). Equivalent of views/error.hbs.
-->
<script setup lang="ts">
import { computed } from 'vue';
import { RouterLink } from 'vue-router';
import { useI18n } from 'vue-i18n';
const props = defineProps<{ code: 403 | 404 }>();
const { t } = useI18n();
const message = computed(() => (props.code === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND'));
</script>
<template>
<div class="card p-4">
<h4 class="text-danger">{{ t('ERROR_PAGE.TITLE') }} {{ code }}</h4>
<p>{{ t(message) }}</p>
<RouterLink to="/" class="btn btn-primary align-self-start">{{ t('ERROR_PAGE.BACK') }}</RouterLink>
</div>
</template>
|
Die Fehlerseite für eine unbekannte URL (404) oder eine auf die Rolle des Benutzers beschränkte Seite (403).