6. 第 5 章 - [RdvMedecins] 应用的 [Angular] 客户端
本章逐个文件地详细讲解本文档随附的 [rdvmedecins-angular-client] 文件夹的内容,采用本课程一贯的格式:逐行编号的源代码,随后是标题为“我们来解读这段代码:”的小节。每个项目文件夹还包含其自己的 README.md 文件。
6.1. 架构概览
与原文档一样,客户端采用分层架构,在此我们称之为V-C-Services(视图-控制器-服务):

术语上有一点差异值得注意:在 AngularJS 1.x 中,视图(HTML 模板)和控制器(相关联的 JavaScript 类)是两个独立的实体,通过 $scope 相连。在 [Angular] 中,它们合并为一个实体,即组件(见上一章)——因此,在后文中,凡是原文档区分视图和控制器的地方,我们都将简单地称为“组件”。
与原文档一样,组件绝不直接与服务器通信:这一职责专属于服务层。这是一条同时适用于 AngularJS 1.x 和 [Angular] 的设计原则——它没有改变。
6.2. 项目树

该结构直接遵循原文档的流程(登录、选择医生/日期、查看日程、预约),只是在这里组织成了独立的 [Angular] 组件,而不是分开的 AngularJS 1.x 控制器和视图。
Bootstrap用于所有视图([node_modules/bootstrap/dist/css/bootstrap.min.css],在 angular.json 中声明)——这是对 Bootstrap 3 的直接演进,原文档已经使用了 Bootstrap 3。
6.3. 项目配置文件

6.3.1. package.json
| {
"name": "rdvmedecins-angular-client",
"version": "0.0.0",
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"watch": "ng build --watch --configuration development",
"test": "ng test"
},
"private": true,
"packageManager": "npm@10.9.7",
"dependencies": {
"@angular/common": "^22.1.0",
"@angular/compiler": "^22.1.0",
"@angular/core": "^22.1.0",
"@angular/forms": "^22.1.0",
"@angular/platform-browser": "^22.1.0",
"@angular/router": "^22.1.0",
"@ngx-translate/core": "^18.0.0",
"@ngx-translate/http-loader": "^18.0.0",
"bootstrap": "^5.3.3",
"rxjs": "~7.8.0",
"tslib": "^2.3.0"
},
"devDependencies": {
"@angular/build": "^22.1.0",
"@angular/cli": "^22.1.0",
"@angular/compiler-cli": "^22.1.0",
"prettier": "^3.8.1",
"typescript": "~6.0.0"
}
}
|
我们来解读这段代码:
- 第 4–10 行:[“scripts”: { … }] ——可用的 `npm run <name>` 命令。`start`(`ng serve`)启动开发服务器,并在任何源文件被修改时自动重新加载——本文档自始至终使用的就是这个命令;
- 第 13–25 行:[“dependencies”: { … }] ——在浏览器中运行应用所需的包:[Angular] 的核心([@angular/core]、[@angular/common]、[@angular/compiler]、[@angular/forms]、[@angular/platform-browser]、[@angular/router])、Bootstrap(仅样式表;见 angular.json)、RxJS([HttpClient] 使用的 Observable),以及——本章引入的——[@ngx-translate/core] 和 [@ngx-translate/http-loader],这是用于界面法语/英语翻译的第三方库(见下文的 [LanguageService] 和 app.config.ts);
- 第 26–32 行:[“devDependencies”: { … }] ——仅在开发期间需要的包(CLI、编译器),绝不会包含在交付给浏览器的最终包中:@angular/cli/@angular/build(CLI 及其编译引擎)、[@angular/compiler-cli](提前编译模板)、TypeScript,以及 Prettier(自动代码格式化工具,本文档中未使用,但默认生成的每个 [Angular] 项目都包含它)。
与 [NestJS] 服务器(commonjs 模块,见第 3 章)不同,默认的 [Angular] 项目以原生ECMAScript模块(import/export)运行——下面 tsconfig.json 中的 "module": "preserve" 就体现了这一点。
6.3.2. angular.json
| {
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"version": 1,
"cli": { "packageManager": "npm" },
"newProjectRoot": "projects",
"projects": {
"rdvmedecins-angular-client": {
"projectType": "application",
"root": "",
"sourceRoot": "src",
"prefix": "app",
"architect": {
"build": {
"builder": "@angular/build:application",
"options": {
"browser": "src/main.ts",
"tsConfig": "tsconfig.app.json",
"assets": [
{ "glob": "**/*", "input": "public" }
],
"styles": [
"node_modules/bootstrap/dist/css/bootstrap.min.css",
"src/styles.css"
]
},
"configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
"defaultConfiguration": "production"
},
"serve": {
"builder": "@angular/build:dev-server",
"configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
"defaultConfiguration": "development"
}
}
}
}
}
|
我们来解读这段代码(为便于阅读,上面压缩了少数几行——随附的文件是完整的):
- 第 11 行:[“prefix”: “app”,] ——应用于项目中每个组件选择器的前缀(app-login、app-schedule 等)——这是一个由编译器强制执行的约定,可防止与潜在的第三方组件发生名称冲突;
- 第 16 行:[“browser”: “src/main.ts”,] ——编译的入口点——与本章后面讲解的是同一个文件;
- 第 18–20 行:[“assets”: [ { “glob”: “**/*”, “input”: “public” } ],] ——将 public/ 文件夹的全部内容原样复制到编译后应用的根目录——正是这一机制使 public/i18n/fr.json 可以通过 URL /i18n/fr.json 访问,这是 TranslateHttpLoader 所请求的地址(见本章后文);
- 第 21–24 行:[“styles”: [ “node_modules/bootstrap/dist/css/bootstrap.min.css”, “src/styles.css” ],] ——全局样式表,在编译时按此顺序拼接:先是 Bootstrap(以便我们自己在 [styles.css] 中的规则必要时可以覆盖它),而无需使用标准的 CSS @import 语句。
该文件在原来的 AngularJS 1.x 项目中没有对应物(当时的编译工具——Grunt、Gulp——是单独配置的);在 [NestJS] 项目(第 3 章)中,nest-cli.json 起着类似的作用,但更为简单。
6.3.3. [tsconfig.json]
| {
"compileOnSave": false,
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"skipLibCheck": true,
"isolatedModules": true,
"experimentalDecorators": true,
"importHelpers": true,
"target": "ES2022",
"module": "preserve"
},
"angularCompilerOptions": {
"enableI18nLegacyMessageIdFormat": false,
"strictInjectionParameters": true,
"strictInputAccessModifiers": true,
"strictTemplates": true
},
"files": [],
"references": [
{ "path": "./tsconfig.app.json" }
]
}
|
我们来剖析这段代码:
- 第 4 行:[“strict”: true,] ——与 [NestJS] 服务器(它只单独启用 strictNullChecks;见第 3 章)不同,客户端启用了 TypeScript 的完全严格模式:每个变量都必须有可确定的类型,每个 null/undefined 值都必须被显式处理。这是一个更为严格的选择,与本文档将 [Angular] 作为“当前最佳实践”的标杆这一做法相一致;
- 第 20 行:[“strictTemplates”: true]——这是该文件中最重要的选项:它将类型检查从 TypeScript 扩展到HTML 模板本身([app.html]、schedule.component.html……)。诸如 {{ doctor.lastNamee }}(拼写错误)或 [canEdit]="auth.isAdmin"(缺少括号)之类的错误,随后会在编译期间被标记出来,就像 .ts 文件中的错误一样——而在 AngularJS 1.x(2014)中并非如此,那样的模板总是能够编译,错误只会在运行时才显现出来(大多数情况下还是悄无声息的);
- 第 22–25 行:[“files”: [], “references”: [ { “path”: “./tsconfig.app.json” } ]] ——这个根文件并不直接编译任何文件("files": []):它通过TypeScript 项目引用机制委托给下面的 tsconfig.app.json,该机制使单个 [Angular] 项目最终可以定义多个共享共同基础的不同构建配置(应用、测试等)。
6.3.4. tsconfig.app.json
| {
"extends": "./tsconfig.json",
"compilerOptions": {
"outDir": "./out-tsc/app",
"types": []
},
"include": [
"src/**/*.ts"
],
"exclude": [
"src/**/*.spec.ts"
]
}
|
我们来解读这段代码:
- 第 2 行:[“extends”: “./tsconfig.json”,] ——基于共同的基础(严格模式、目标 ES2022……)进行扩展,而不是重新定义所有内容;
- 第 8 行:[“src/**/*.ts”] ——项目中的所有 .ts 文件,包括(例如)本章新增的 language.service.ts;
- 第 11 行:[“src/**/*.spec.ts”] ——单元测试文件(本项目中没有,但按惯例予以排除)使用各自的配置单独编译——本文档不涉及。
6.4. 启动应用

6.4.1. src/index.html
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>RdvMedecins - Angular client</title>
<base href="/">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" type="image/x-icon" href="favicon.ico">
</head>
<body>
<app-root></app-root>
</body>
</html>
|
我们来解读这段代码:
- 第 2 行:[<html lang="en">] ——页面的默认语言,有利于无障碍访问和搜索引擎。由于该页面(HTML)是静态的(在 [Angular] 应用启动之前由浏览器加载),它显然无法立即反映用户之后做出的语言选择;是 [LanguageService](见下文)在用户切换到法语时动态更新此属性;
- 第 11 行:[] ——根组件选择器([App],见 app.ts:selector: 'app-root'):这是页面最初包含的唯一元素,[Angular] 在启动后会完全填充它。这与 AngularJS 1.x(2014)的原则完全相同,后者在原项目的 [app.html] 文件中的 <html> 标签上设置了 ng-app="rdvmedecinsApp"——一个几乎为空的 HTML 页面,完全由 JavaScript 框架控制。
6.4.2. [src/main.ts]
| import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { App } from './app/app';
bootstrapApplication(App, appConfig).catch((err) => console.error(err));
|
我们来解读这段代码:
- 第 5 行:[bootstrapApplication(App, appConfig).catch((err) => console.error(err));] ——通过指定根组件([App])及其配置(appConfig;见下文的 app.config.ts)来启动应用;bootstrapApplication 是独立[Angular] 应用(不使用 NgModule)的启动函数,它取代了旧版 Angular 中的 platformBrowserDynamic().bootstrapModule([AppModule])。.catch(...) 捕获启动过程本身中发生的任何错误(在应用的任何代码行执行之前)——这种情况既罕见又严重,值得与应用通常的错误处理分开单独处理。
整个应用只有一个入口点:这正是单页 Web 应用的定义(SPA),原文档中已经描述过。
6.4.3. [src/styles.css]
| body {
background-color: #f5f7fa;
}
.free-slot {
cursor: pointer;
}
.free-slot:hover {
background-color: #e9f7ef;
}
|
我们来解读这段代码:
- 第 1 行:[body { background-color: #f5f7fa; }] ——使用非常浅的灰色,而不是默认的纯白色,使 Bootstrap 卡片(白色背景,.card)从页面背景中略微凸显出来;
- 第 5–10 行:[.free-slot] ——应用于日历表中表示可用时间段的行(见 schedule.component.html,[class.free-slot]="scheduleSlot.appointment === null"):鼠标悬停时光标变为手形(cursor: pointer),背景略微变绿,以提示该行可点击——甚至在点击之前就是如此。
该文件包含全局样式,与之相对的是每个组件的 .css 文件(schedule.component.css……)中定义的“局部”样式,后者只作用于该组件的模板。根组件的样式表 src/app/app.css 保持为空:Bootstrap 和 [styles.css] 已足以满足本文档实现的全部内容。
6.5. core/models 层

6.5.1. src/app/core/models/appointment.models.ts
| export interface ServerResponse<T> {
status: number;
data: T | null;
}
export interface Doctor {
id: number;
title: string;
lastName: string;
firstName: string;
}
export interface Client {
id: number;
title: string;
lastName: string;
firstName: string;
}
export interface SlotJson {
id: number;
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
export interface AppointmentJson {
id: number;
day: string;
client: Client | null;
slot: SlotJson | null;
}
export interface ScheduleSlot {
slot: SlotJson;
appointment: AppointmentJson | null;
}
export interface DoctorDaySchedule {
doctor: Doctor;
day: string;
slots: ScheduleSlot[];
}
export type Role = 'ADMIN' | 'USER';
export interface LoginResult {
accessToken: string;
login: string;
name: string;
role: Role;
}
|
我们来解读这段代码:
- 第 1–4 行:[export interface ServerResponse { status: number; data: T | null; }] ——与服务器端的类 [ServerResponse]<T>(见第 3 章)完全对应:每个 JSON 响应都是这种形式;
- 第 6–18 行:[Doctor / Client] ——两个形式相同的接口,对应于同名的 [TypeORM] 实体(第 3 章)。提醒:此处的 [Client] 指的是患者,而不是“HTTP 客户端”;
- 第 20–33 行:[SlotJson / AppointmentJson] ——由服务器端的 getMapForSlot/getMapForAppointment(第 3 章,static.helper.ts)生成的“轻量”版本;
- 第 40–44 行:[export interface DoctorDaySchedule { … }] ——对应于 GET /getDoctorScheduleOfDay/:doctorId/:day 的响应;
- 第 46 行:[export type Role = ‘ADMIN’ | ‘USER’;] ——服务器端 [Role] 类型(src/entities/user.entity.ts)的精确副本;
- 第 48–53 行:[export interface LoginResult { … }]——POST /login 返回的数据格式(见下文的 [AuthService]),是服务器端同名接口(auth/login-result.model.ts)的精确副本。
在 AngularJS 1.x(2014)中,原始的 JavaScript 无法以这种方式描述期望的数据格式:服务器响应被当作任意对象处理,执行之前不进行任何验证。而有了 TypeScript,字段名中的拼写错误现在在程序执行之前——即编译期间——就会被标记出来。
6.6. core/services 层

6.6.1. src/app/core/services/settings.service.ts
| import { Injectable, signal } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class SettingsService {
readonly apiBaseUrl = signal('http://localhost:8080');
setApiBaseUrl(url: string): void {
this.apiBaseUrl.set(url);
}
}
|
我们来解读这段代码:
- 第 3 行:[@Injectable({ providedIn: 'root' })] ——将服务声明为应用的全局单例:[Angular] 在组件首次需要它时自动创建它的唯一实例——相当于 AngularJS 1.x 中用 .service() 或 .factory() 声明的服务的现代等价物;
- 第 5 行:[readonly apiBaseUrl = signal(‘http://localhost:8080’);] ——signal(...) 创建一个响应式值:在 [Angular] 模板中读取 apiBaseUrl() 的任何地方,只要其值发生变化就会被自动通知——这是现代 [Angular] 的核心响应式机制,它取代了 AngularJS 1.x 的观察机制($watch/$scope.$apply);
- 第 7–9 行:[setApiBaseUrl(url: string): void { this.apiBaseUrl.set(url); }] ——取自原文档主页视图上的“服务器 URL”字段,该字段当时就已允许用户通过界面修改它(当服务器运行在不同端口时很有用)。
6.6.2. src/app/core/services/appointment.service.ts
| import { Injectable, inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, map } from 'rxjs';
import { SettingsService } from './settings.service';
import { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';
@Injectable({ providedIn: 'root' })
export class AppointmentService {
private readonly http = inject(HttpClient);
private readonly settings = inject(SettingsService);
getAllDoctors(): Observable<Doctor[]> {
return this.http
.get<ServerResponse<Doctor[]>>(`${this.settings.apiBaseUrl()}/getAllDoctors`)
.pipe(map((response) => this.extract(response)));
}
getAllClients(): Observable<Client[]> {
return this.http
.get<ServerResponse<Client[]>>(`${this.settings.apiBaseUrl()}/getAllClients`)
.pipe(map((response) => this.extract(response)));
}
getDoctorScheduleOfDay(doctorId: number, day: string): Observable<DoctorDaySchedule> {
return this.http
.get<ServerResponse<DoctorDaySchedule>>(
`${this.settings.apiBaseUrl()}/getDoctorScheduleOfDay/${doctorId}/${day}`,
)
.pipe(map((response) => this.extract(response)));
}
addAppointment(day: string, clientId: number, slotId: number): Observable<AppointmentJson> {
return this.http
.post<ServerResponse<AppointmentJson>>(`${this.settings.apiBaseUrl()}/addAppointment`, { day, clientId, slotId })
.pipe(map((response) => this.extract(response)));
}
deleteAppointment(appointmentId: number): Observable<void> {
return this.http
.post<ServerResponse<null>>(`${this.settings.apiBaseUrl()}/deleteAppointment`, { appointmentId })
.pipe(map(() => undefined));
}
private extract<T>(response: ServerResponse<T>): T {
if (response.status !== 0) {
throw new Error(`The server responded with error status ${response.status}`);
}
return response.data as T;
}
}
|
我们来解读这段代码:
- 第 8 行:[export class AppointmentService {] ——直接等价于原文档“示例 6:HTTP 服务”一章中介绍的 DAO 服务(它使用了 AngularJS 的 $http 服务)。与传统的服务器端应用不同(其中 Web 层只能通过业务层与 DAO 层通信),客户端允许表示层(我们的组件)直接调用该服务——客户端没有单独的“业务层”;
- 第 9 行:[private readonly http = inject(HttpClient);] ——`inject()` 是在 [Angular] 中获取依赖的现代方式(它取代了传统的构造函数注入);
- 第 12–16 行:[getAllDoctors(): Observable<Doctor[]> { … }] ——等价于 GET /getAllDoctors;每个方法都恰好对应 [NestJS] 控制器(第 3 章)中十一个路由之一——事实上,两边出现的名称相同,这便于对照服务器端和客户端代码;
- 第 44 行:[private extract<T>(response: ServerResponse<T>): T {] ——我们没有在每个公共方法中重复“如果 status !== 0,则表示出错”的检查,而是只在这里集中处理一次;
- 第 46 行:[throw new Error(…)] ——在 `map()` 中抛出的 JavaScript 异常会被 RxJS 自动重定向到订阅的 `error` 分支(.subscribe({ next, error }))——这一机制使根组件无需了解 [ServerResponse]<T> 信封的细节,就能显示错误消息。
6.6.3. src/app/core/services/auth.service.ts
该服务负责管理用户的连接:调用 POST /login,将收到的 JWT 令牌(及随附的身份/角色)存储为信号,并借助 localStorage 确保其在页面重新加载后仍然保留。它与 [AppointmentService] 一起,是应用中仅有的另一个使用 HTTP 与服务器通信的地方——这是对“单一 HTTP 服务”规则的有意例外,它在客户端反映了服务器端已经做出的 RdvMedecinsController 与 AuthController 之间的分离。
| import { Injectable, computed, inject, signal } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, map, tap } from 'rxjs';
import { SettingsService } from './settings.service';
import { LoginResult, ServerResponse, Role } from '../models/appointment.models';
interface StoredSession {
accessToken: string;
login: string;
name: string;
role: Role;
}
const STORAGE_KEY = 'rdvmedecins.session';
@Injectable({ providedIn: 'root' })
export class AuthService {
private readonly http = inject(HttpClient);
private readonly settings = inject(SettingsService);
private readonly session = signal<StoredSession | null>(readStoredSession());
readonly isLoggedIn = computed(() => this.session() !== null);
readonly login = computed(() => this.session()?.login ?? null);
readonly name = computed(() => this.session()?.name ?? null);
readonly role = computed(() => this.session()?.role ?? null);
readonly isAdmin = computed(() => this.role() === 'ADMIN');
readonly accessToken = computed(() => this.session()?.accessToken ?? null);
logIn(login: string, password: string): Observable<LoginResult> {
return this.http
.post<ServerResponse<LoginResult>>(`${this.settings.apiBaseUrl()}/login`, { login, password })
.pipe(
map((response) => {
if (response.status !== 0 || response.data === null) {
throw new Error('Login failed');
}
return response.data;
}),
tap((result) => this.saveSession(result)),
);
}
logOut(): void {
this.session.set(null);
localStorage.removeItem(STORAGE_KEY);
}
private saveSession(result: LoginResult): void {
const newSession: StoredSession = result;
this.session.set(newSession);
localStorage.setItem(STORAGE_KEY, JSON.stringify(newSession));
}
}
function readStoredSession(): StoredSession | null {
try {
const raw = localStorage.getItem(STORAGE_KEY);
return raw ? (JSON.parse(raw) as StoredSession) : null;
} catch {
return null;
}
}
|
我们来解读这段代码:
- 第 7–12 行:[interface StoredSession { … }] ——写入 localStorage / 从 localStorage 读取的内容的格式——一个简单的 JSON 对象,有意与 [LoginResult] 区分开(尽管它包含了后者的所有字段);
- 第 21 行:[private readonly session = signal<StoredSession | null>(readStoredSession());] ——由 localStorage 初始化:如果用户在登录后重新加载页面,他们仍保持登录状态(直到令牌在服务器端过期,或他们显式注销);
- 第 22 行:[readonly isLoggedIn = computed(() => this.session() !== null);] ——`computed()` 创建一个派生信号:每当会话变化时,其值都会被自动重新计算,而任何读取它的组件([app.html] 中的 auth.isLoggedIn())也会随之得到通知;
- 第 23–26 行:[login / name / role / isAdmin] ——派生信号,以只读方式暴露给组件(app.ts、login.component.ts,以及通过 canEdit 暴露给 schedule.component.ts);
- 第 28 行:[readonly accessToken = computed(() => this.session()?.accessToken ?? null);] ——每个受保护的 HTTP 请求都要携带的令牌,由 auth.interceptor.ts(见下文)读取;
- 第 30 行:[logIn(login: string, password: string): Observable {] ——等价于 POST /login,请求体为 JSON { login, password };
- 第 34–39 行:[map((response) => { if (response.status !== 0 …) { throw …; } return response.data; })] ——与 AppointmentService.extract() 的原理相同,这里改写成了内联代码而不是方法调用(两个服务之间不共享私有方法,它们有意保持独立);
- 第 40 行:[tap((result) => this.saveSession(result)),] ——`tap()` 执行一个副作用(这里是保存会话),而不会改变随后传递给订阅者的值——与会转换该值的 `map()` 不同;
- 第 44–47 行:[logOut(): void { this.session.set(null); localStorage.removeItem(…); }] ——纯本地操作(不调用服务器):在这个初始移植版本中,JWT 令牌不会在服务器端被“撤销”;它会在 JWT_EXPIRES_IN 之后自行过期;
- 第 56 行:[function readStoredSession(): StoredSession | null {] ——由 try/catch 块保护:localStorage 可能不可用(由于非常严格的隐私浏览模式),或包含已损坏的值——在这种情况下,我们简单地认为不存在会话。
6.6.4. src/app/core/services/language.service.ts
一个小型服务,集中处理界面语言(法语/英语)的切换。它依赖 [TranslateService]([@ngx-translate/core],在下面的 app.config.ts 中配置)完成实际的翻译工作,并补充了 [SettingsService] 和 [AuthService] 中已有的做法:向应用其余部分暴露一个信号,并将用户的选择存储在 localStorage 中。
| import { Injectable, inject } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
const STORAGE_KEY = 'rdvmedecins.language';
export type Language = 'fr' | 'en';
@Injectable({ providedIn: 'root' })
export class LanguageService {
private readonly translate = inject(TranslateService);
readonly currentLanguage = this.translate.currentLang;
constructor() {
const initialLanguage = (localStorage.getItem(STORAGE_KEY) as Language | null) ?? (navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : null);
if (initialLanguage && initialLanguage !== this.translate.getCurrentLang()) {
this.applyLanguage(initialLanguage);
}
}
changeLanguage(language: Language): void {
localStorage.setItem(STORAGE_KEY, language);
this.applyLanguage(language);
}
private applyLanguage(language: Language): void {
this.translate.use(language).subscribe(() => {
document.documentElement.lang = language;
});
}
}
|
我们来剖析这段代码:
- 第 10 行:[private readonly translate = inject(TranslateService);] ——[TranslateService] 是 [@ngx-translate/core] 的核心服务:它负责加载翻译字典,并将键('LOGIN.TITLE')解析为文本('Login' 或 'Connexion',取决于当前语言);
- 第 12 行:[readonly currentLanguage = this.translate.currentLang;] ——自 [@ngx-translate/core] 第 18 版起,[TranslateService] 已将 currentLang 作为事件信号暴露出来:无需在这里重新创建,我们只是以这个名称重新发布它——这样应用其余的代码(见 [app.html])就永远不需要导入 [TranslateService] 本身,只需导入 [LanguageService];
- 第 14–19 行:[constructor() { const initialLanguage = …; if (…) { this.applyLanguage(initialLanguage); } }]——启动时:如果用户在之前的访问中已经选择了语言,则恢复该语言;否则,如果浏览器是法语的则使用法语,否则保留 app.config.ts 中设置的默认语言(英语);
- 第 21–24 行:[changeLanguage(language: Language): void { localStorage.setItem(…); this.applyLanguage(language); }] ——由导航栏上的 FR/EN 两个按钮调用(见 [app.html]);
- 第 26–30 行:[private applyLanguage(language: Language): void { this.translate.use(language).subscribe(() => { document.documentElement.lang = language; }); }] ——translate.use(language) (如有必要)加载对应的 public/i18n/<language>.json 文件,然后切换当前语言;它是一个 Observable,在加载完成后发出一个信号——我们借此机会更新页面的 <html lang="..."> 属性(有利于无障碍访问),[Angular] 自身不会处理这一点,因为 index.html 是在应用启动之前就已加载的静态页面。
相当于原 AngularJS 1.x 客户端中的“FR / EN”按钮,后者当时依赖 angular-translate 库——它是此处所用 ngx-translate 在 AngularJS 1.x 生态系统中的前身。
6.7. 翻译字典(public/i18n/)
TranslateHttpLoader([@ngx-translate/http-loader],在下面的 app.config.ts 中配置)在语言发生变化(或首次使用)时,通过 HTTP GET [/i18n/]<language>.json 请求加载这两个文件之一。随后 [TranslateService] 将该 JSON 展平为字典 "LOGIN.TITLE"、"SCHEDULE.FREE"……,供 features/ 目录中所有模板使用的 | translate 管道查询(见本章后文)。

6.7.1. public/i18n/fr.json
| {
"APP": {
"TITLE": "RdvMedecins - portage NestJS / Angular",
"SERVER_URL_LABEL": "URL du serveur",
"LOGOUT": "Se déconnecter"
},
"LOGIN": {
"TITLE": "Connexion",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Mot de passe",
"SUBMIT": "Se connecter",
"SUBMITTING": "Connexion...",
"ERROR": "Login ou mot de passe incorrect.",
"DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
"DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
"DEMO_ACCOUNTS_OR": "ou",
"DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Médecin",
"CHOOSE_DOCTOR": "-- choisir un médecin --",
"DAY_LABEL": "Jour",
"VIEW_SCHEDULE": "Voir l'agenda"
},
"SCHEDULE": {
"TITLE_PREFIX": "Agenda du",
"COLUMN_SLOT": "Créneau",
"COLUMN_STATUS": "Statut",
"FREE": "Libre",
"BOOK": "Réserver",
"CANCEL_APPOINTMENT": "Annuler",
"EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda »."
},
"BOOKING_DIALOG": {
"TITLE": "Réserver ce créneau",
"CLOSE_ARIA": "Fermer",
"SLOT_FROM": "Créneau de",
"SLOT_TO": "à",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choisir un patient --",
"CANCEL": "Annuler",
"CONFIRM": "Confirmer"
}
}
|
我们来解读这段代码:
- 第 1 行:[{] ——一个嵌套的 JSON 对象,每个组件一个部分(APP、LOGIN、DOCTOR_DAY_PICKER、SCHEDULE、BOOKING_DIALOG);[TranslateService] 将其展平为一个扁平的字典,其中每个完整的键("LOGIN.TITLE")由路径以点号连接而成;
- 第 14–17 行:[“DEMO_ACCOUNTS_PREFIX” / “DEMO_ACCOUNTS_ADMIN” / “DEMO_ACCOUNTS_OR” / “DEMO_ACCOUNTS_USER”] ——一个短语被拆分为四个键,而不是一个键:原文档的完整文本(“Demo accounts: admin / admin (role ADMIN…) or user / user (role USER…) ”)还包含不得翻译的 <code>admin</code> 元素(它们是登录凭据,在两种语言中相同)——因此必须把它们插入到已翻译的片段之间(见下面的 login.component.html);
- 第 32 行:[“EMPTY_STATE”: “Choisissez un médecin et un jour, puis cliquez sur « Voir l’agenda ».”] ——与大多数其他键(只是简单的标签)不同,这一个是完整的句子:翻译键完全可以包含标点或多个单词,只要它对应模板中的单个文本块即可。
6.7.2. public/i18n/en.json
| {
"APP": {
"TITLE": "RdvMedecins - NestJS / Angular port",
"SERVER_URL_LABEL": "Server URL",
"LOGOUT": "Log out"
},
"LOGIN": {
"TITLE": "Login",
"LOGIN_LABEL": "Login",
"PASSWORD_LABEL": "Password",
"SUBMIT": "Log in",
"SUBMITTING": "Signing in...",
"ERROR": "Incorrect login or password.",
"DEMO_ACCOUNTS_PREFIX": "Demo accounts:",
"DEMO_ACCOUNTS_ADMIN": "(ADMIN role, full access)",
"DEMO_ACCOUNTS_OR": "or",
"DEMO_ACCOUNTS_USER": "(USER role, read-only)"
},
"DOCTOR_DAY_PICKER": {
"DOCTOR_LABEL": "Doctor",
"CHOOSE_DOCTOR": "-- choose a doctor --",
"DAY_LABEL": "Day",
"VIEW_SCHEDULE": "View schedule"
},
"SCHEDULE": {
"TITLE_PREFIX": "Schedule for",
"COLUMN_SLOT": "Slot",
"COLUMN_STATUS": "Status",
"FREE": "Free",
"BOOK": "Book",
"CANCEL_APPOINTMENT": "Cancel",
"EMPTY_STATE": "Choose a doctor and a day, then click "View schedule"."
},
"BOOKING_DIALOG": {
"TITLE": "Book this slot",
"CLOSE_ARIA": "Close",
"SLOT_FROM": "Slot from",
"SLOT_TO": "to",
"PATIENT_LABEL": "Patient",
"CHOOSE_PATIENT": "-- choose a patient --",
"CANCEL": "Cancel",
"CONFIRM": "Confirm"
}
}
|
我们来剖析这段代码:
- 第 3 行:[“TITLE”: “RdvMedecins - NestJS / Angular port”,] ——只有副标题会变化:“[RdvMedecins]”在两种语言中保持不变;这是应用的专有名称;
- 第 11 行:[“SUBMIT”: “Log in”,] ——采用的是适配性翻译而非直译(“Connect”本来是从法语直译而来的):标准的英语身份验证术语区分“log in”(动词,登录这一动作)与“login”(名词,输入的用户名——见第 9 行,它在两种语言中都保持为“[Login]”,因为它同时也是服务器所期望的字段名;见第 3 章的 [LoginDto])。
这两个文件必须保持结构完全相同(两者的键相同):这可确保某个键在两种语言中都存在。如果两个文件之一缺少某个键,在补上之前,界面将按原样显示它(即其原始名称),而不是其翻译。
未被翻译的内容:服务器返回的错误消息(见第 3 章,[ServerResponse]<T> 信封)无论客户端选择哪种语言,都保持为英语——翻译这些消息需要服务器端的国际化,这超出了本步骤的范围(见第 6 章“结论”)。而医生和患者的姓名则直接来自数据库,在两种情况下当然都不会被翻译。
6.8. core/interceptors 层

6.8.1. src/app/core/interceptors/auth.interceptor.ts
HTTP 拦截器插入在 [HttpClient] 与网络之间:它拦截每一个发出的请求(及其响应),并可以对它们进行修改。这是原文档(“示例 6”一章)中已经讨论过的 AngularJS 1.x $http 拦截器的现代等价物——形式变了(是一个简单的函数,而不是带有 request/response 方法的对象),但思想仍然相同。
| import { inject } from '@angular/core';
import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { catchError, throwError } from 'rxjs';
import { AuthService } from '../services/auth.service';
export const authInterceptor: HttpInterceptorFn = (request, next) => {
const auth = inject(AuthService);
const token = auth.accessToken();
const requestWithToken = token
? request.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
: request;
return next(requestWithToken).pipe(
catchError((error: unknown) => {
if (error instanceof HttpErrorResponse && error.status === 401) {
auth.logOut();
}
return throwError(() => error);
}),
);
};
|
我们来解读这段代码:
- 第 6 行:[export const authInterceptor: HttpInterceptorFn = (request, next) => {] ——在过去的几个版本中,[Angular] 更青睐函数式拦截器([HttpInterceptorFn])——即一个简单的函数——而不是早期 [Angular] 版本中基于类的拦截器:编写更简短,注册更简单(见 app.config.ts,withInterceptors([...]));
- 第 10–12 行:[request.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : request;] ——[HttpClient] 请求是一个不可变对象——不能直接修改其请求头,必须创建一个修改后的副本。沿链传递下去的必须是这个副本(requestWithToken),绝不能是未经修改的原始请求;
- 第 15–18 行:[catchError((error) => { if (error instanceof HttpErrorResponse && error.status === 401) { auth.logOut(); } … })] ——会话期间出现 401 错误意味着令牌已不再有效(已过期,或服务器已重启):此时客户端会被妥善地断开连接,而不是停留在不一致的状态(表面上已连接,但所有请求都不成功);
- 第 19 行:[return throwError(() => error);] ——处理之后,错误被原样重新抛出:拦截器不得向调用方代码隐藏该错误(例如经由 [App] 的 [ScheduleComponent]),而只是在此过程中处理一种特定情况。
我们本可以手动将 Authorization: Bearer ... 添加到 AppointmentService 的每个方法中。拦截器避免了这种重复:“如何对请求进行身份验证?”这个问题只在一处一次性解决,并将自动应用于将来任何使用 HttpClient 的服务。它在 app.config.ts(见下文)中通过provideHttpClient(withInterceptors([authInterceptor]))注册:没有这一行,该函数虽然存在,却永远不会被调用。
6.9. 应用配置

6.9.1. src/app/app.config.ts
| import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { provideRouter } from '@angular/router';
import { provideTranslateService } from '@ngx-translate/core';
import { provideTranslateHttpLoader } from '@ngx-translate/http-loader';
import { routes } from './app.routes';
import { authInterceptor } from './core/interceptors/auth.interceptor';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideRouter(routes),
provideHttpClient(withInterceptors([authInterceptor])),
provideTranslateService({
lang: 'en',
fallbackLang: 'en',
loader: provideTranslateHttpLoader({ prefix: '/i18n/', suffix: '.json' }),
}),
],
};
|
我们来解读这段代码:
- 第 9 行:[export const appConfig: ApplicationConfig = {] ——根组件([App])运行所需接收的内容。这是“独立”[Angular] 应用(不使用 NgModule)特有的概念:每个 provideXxx() 激活一个跨应用的服务;原 AngularJS 1.x 项目中没有与该文件直接对应的东西;
- 第 12 行:[provideRouter(routes),] ——激活 Angular 路由器。我们的应用只有一个页面:登录屏幕是一个由 [App] 有条件地显示的组件([LoginComponent]),而不是专门的路由(见下面的 app.routes.ts);
- 第 13 行:[provideHttpClient(withInterceptors([authInterceptor])),] ——激活 [HttpClient],由 [AppointmentService] 和 [AuthService] 使用——这是 AngularJS 1.x $http 服务的现代等价物。withInterceptors ([authInterceptor]) 注册身份验证拦截器:没有这一行,authInterceptor 虽然存在,却永远不会被调用;
- 第 14–18 行:[provideTranslateService({ lang: ‘en’, fallbackLang: ‘en’, loader: provideTranslateHttpLoader({ prefix: ‘/i18n/’, suffix: ‘.json’ }), }),] ——激活 [@ngx-translate/core],这是用于在法语和英语之间切换界面的库。lang: 'en' 设置启动语言([LanguageService],见上文,会立即用已存储在 localStorage 中的选择(如果有)替换它,或者在浏览器为法语时替换为法语);如果当前语言的字典中缺少某个翻译键,则会使用 fallbackLang: 'en';loader: provideTranslateHttpLoader(...) 指明了如何加载字典——这里是通过对静态 JSON 文件(public/i18n/fr.json、public/i18n/en.json,见上文)发出 HTTP GET 请求,前缀和后缀共同构成完整的 URL(前缀 + 语言 + 后缀,例如 /i18n/en.json)。
6.9.2. src/app/app.routes.ts
| import { Routes } from '@angular/router';
export const routes: Routes = [];
|
我们来解读这段代码:
- 第 3 行:[export const routes: Routes = [];] ——路由表保持为空:应用只有一个页面(根组件 [App] 根据 AuthService.isLoggedIn() 显示登录屏幕,或者显示医生/日期选择器 + 日历 + 预约窗口)。我们本可以创建一个 /login 路由来代替条件显示,但对于单页应用来说,这种变通做法毫无意义。
6.10. features 层:四个组件

6.10.1. src/app/features/login/login.component.ts
登录屏幕:相当于原 AngularJS 1.x 客户端的视图 [login.html](应用显示的第一个视图)。
| import { Component, DestroyRef, inject, signal } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { TranslatePipe } from '@ngx-translate/core';
import { AuthService } from '../../core/services/auth.service';
@Component({
selector: 'app-login',
imports: [TranslatePipe],
templateUrl: './login.component.html',
styleUrl: './login.component.css',
})
export class LoginComponent {
private readonly auth = inject(AuthService);
private readonly destroyRef = inject(DestroyRef);
protected readonly login = signal('');
protected readonly password = signal('');
protected readonly inProgress = signal(false);
protected readonly error = signal<string | null>(null);
onLoginChange(event: Event): void {
this.login.set((event.target as HTMLInputElement).value);
}
onPasswordChange(event: Event): void {
this.password.set((event.target as HTMLInputElement).value);
}
onSubmit(): void {
if (this.login().trim() === '' || this.password() === '') {
return;
}
this.error.set(null);
this.inProgress.set(true);
this.auth
.logIn(this.login(), this.password())
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe({
next: () => this.inProgress.set(false),
error: () => {
this.inProgress.set(false);
this.error.set('LOGIN.ERROR');
},
});
}
}
|
我们来解读这段代码:
- 第 8 行:[imports: [TranslatePipe],] ——独立组件要声明其模板中使用的管道;[TranslatePipe]([@ngx-translate/core])使 login.component.html(见下文)中可以使用 | translate;
- 第 16–17 行:[protected readonly login = signal(’‘); protected readonly password = signal(’’);] ——纯粹属于表单本地的状态(用户当前正在输入的内容);
- 第 19 行:[protected readonly inProgress = signal(false);] ——在网络调用期间为 true:禁用按钮以防止双击;
- 第 20 行:[protected readonly error = signal<string | null>(null);] ——存储的是翻译键,而不是已翻译好的文本:模板中的 | translate 管道在显示时才解析它;
- 第 30 行:[onSubmit(): void {] ——由“Log in”按钮触发(见下面的模板);
- 第 40 行:[next: () => this.inProgress.set(false),] ——这里无需进一步处理:[AuthService] 已经存储了会话(信号 + localStorage)——是读取 auth.isLoggedIn() 的 [App] 会做出响应,停止显示 <app-login>;
- 第 41–44 行:[error: () => { …this.error.set(‘LOGIN.ERROR’); }] ——无效的用户名/密码组合会使 logIn() 以 HTTP 401 错误失败(见第 3 章,[LocalStrategy]):用户只会看到 'LOGIN.ERROR'(“Incorrect login or password.” / “Login ou mot de passe incorrect.”,取决于语言),不会尝试区分用户名不存在和密码错误(这是一种预防措施,任何真实应用都会这样做)。存储键而不是纯文本有一个实际的好处:如果用户在显示此消息时切换语言,消息会自动重新翻译,这里无需任何额外的代码。
6.10.2. src/app/features/login/login.component.html
| <div class="row justify-content-center">
<div class="col-sm-8 col-md-6 col-lg-4">
<div class="card p-4">
<h5 class="card-title mb-3">{{ 'LOGIN.TITLE' | translate }}</h5>
@if (error(); as errorMessage) {
<div class="alert alert-danger py-2" role="alert">{{ errorMessage | translate }}</div>
}
<div class="mb-3">
<label class="form-label" for="input-login">{{ 'LOGIN.LOGIN_LABEL' | translate }}</label>
<input id="input-login" type="text" class="form-control" autocomplete="username"
[value]="login()" (input)="onLoginChange($event)" (keyup.enter)="onSubmit()">
</div>
<div class="mb-3">
<label class="form-label" for="input-password">{{ 'LOGIN.PASSWORD_LABEL' | translate }}</label>
<input id="input-password" type="password" class="form-control" autocomplete="current-password"
[value]="password()" (input)="onPasswordChange($event)" (keyup.enter)="onSubmit()">
</div>
<button type="button" class="btn btn-primary w-100" [disabled]="inProgress()" (click)="onSubmit()">
@if (inProgress()) { {{ 'LOGIN.SUBMITTING' | translate }} } @else { {{ 'LOGIN.SUBMIT' | translate }} }
</button>
<p class="text-muted small mt-3 mb-0">
{{ 'LOGIN.DEMO_ACCOUNTS_PREFIX' | translate }} <code>admin</code> / <code>admin</code> {{ 'LOGIN.DEMO_ACCOUNTS_ADMIN' | translate }}
{{ 'LOGIN.DEMO_ACCOUNTS_OR' | translate }} <code>user</code> / <code>user</code> {{ 'LOGIN.DEMO_ACCOUNTS_USER' | translate }}.
</p>
</div>
</div>
</div>
|
我们来剖析这段代码:
- 第 1–2 行:[] ——Bootstrap 网格类:无论屏幕宽度如何,都使固定宽度的卡片水平居中;
- 第 12–13、18–19 行:[(input)=“onLoginChange($event)” (keyup.enter)=“onSubmit()”] ——不使用 FormsModule/ngModel:字段直接通过 DOM 的 (input) 事件读取,而 (keyup.enter) 允许使用键盘提交表单,无需鼠标;
- 第 22 行:[[disabled]=“inProgress()”] ——按钮在网络调用期间被禁用(见 LoginComponent.inProgress),以防止第一次尝试尚未完成时发生双击;
- 第 27–28 行:[{{ ‘LOGIN.DEMO_ACCOUNTS_PREFIX’ | translate }} admin / admin {{ ‘LOGIN.DEMO_ACCOUNTS_ADMIN’ | translate }} …] ——演示账户的文本在已翻译的文本和未翻译的标识符(<code>admin</code>、<code>user</code>)之间交替出现:为了支持这种混合,该短语在 JSON 字典中被拆分成四个独立的键(见上文 public/i18n/fr.json),而不是一个包含整个短语的键。
6.10.3. src/app/features/doctor-day-picker/doctor-day-picker.component.ts
该组件允许你选择医生和日期,然后查看其日程。在概念上相当于原 AngularJS 1.x 客户端中的示例 7 至 10。
| import { Component, input, output, signal } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { Doctor } from '../../core/models/appointment.models';
@Component({
selector: 'app-doctor-day-picker',
imports: [TranslatePipe],
templateUrl: './doctor-day-picker.component.html',
styleUrl: './doctor-day-picker.component.css',
})
export class DoctorDayPickerComponent {
readonly doctors = input.required<Doctor[]>();
readonly search = output<{ doctorId: number; day: string }>();
readonly selectedDoctorId = signal<number | null>(null);
readonly selectedDay = signal<string>(new Date().toISOString().slice(0, 10));
onDoctorChange(event: Event): void {
const value = (event.target as HTMLSelectElement).value;
this.selectedDoctorId.set(value === '' ? null : Number(value));
}
onDayChange(event: Event): void {
this.selectedDay.set((event.target as HTMLInputElement).value);
}
onSearchClick(): void {
const doctorId = this.selectedDoctorId();
if (doctorId === null) {
return;
}
this.search.emit({ doctorId, day: this.selectedDay() });
}
}
|
我们来剖析这段代码:
- 第 7 行:[imports: [TranslatePipe],] ——使 doctor-day-picker.component.html(见下文)中可以使用 | translate;
- 第 12 行:[readonly doctors = input.required<Doctor[]>();] ——声明该组件必须从其父组件([App])接收医生列表——如果使用该组件时没有提供此输入,[Angular] 会报错。input()(基于信号)取代了传统的 @Input() 关键字:[doctors]() 被当作函数处理,这使 [Angular] 能够准确知道何时重绘该组件;
- 第 13 行:[readonly search = output<{ doctorId: number; day: string }>();]——声明该组件向其父组件传播的事件——相当于 AngularJS 1.x 中的自定义事件($emit/$broadcast);
- 第 15–16 行:[selectedDoctorId / selectedDay] ——该组件特有的状态(在用户尚未点击按钮时,菜单中所选择的内容);selectedDay 初始化为今天的日期;
- 第 27–33 行:[onSearchClick(): void { … this.search.emit({ doctorId, day: … }); }] ——它自己并不调用 HTTP:只是将用户的意图向上传递给其父组件,由父组件决定是否调用 AppointmentService。
6.10.4. src/app/features/doctor-day-picker/doctor-day-picker.component.html
| <div class="card p-3 mb-3">
<div class="row g-2 align-items-end">
<div class="col-sm-5">
<label class="form-label" for="select-doctor">{{ 'DOCTOR_DAY_PICKER.DOCTOR_LABEL' | translate }}</label>
<select id="select-doctor" class="form-select" (change)="onDoctorChange($event)">
<option value="">{{ 'DOCTOR_DAY_PICKER.CHOOSE_DOCTOR' | translate }}</option>
@for (doctor of doctors(); track doctor.id) {
<option [value]="doctor.id">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</option>
}
</select>
</div>
<div class="col-sm-4">
<label class="form-label" for="input-day">{{ 'DOCTOR_DAY_PICKER.DAY_LABEL' | translate }}</label>
<input id="input-day" type="date" class="form-control" [value]="selectedDay()" (change)="onDayChange($event)">
</div>
<div class="col-sm-3">
<button type="button" class="btn btn-primary w-100" [disabled]="selectedDoctorId() === null" (click)="onSearchClick()">
{{ 'DOCTOR_DAY_PICKER.VIEW_SCHEDULE' | translate }}
</button>
</div>
</div>
</div>
|
我们来剖析这段代码:
- 第 7 行:[@for (doctor of doctors(); track doctor.id) {] ——[@for] 是 [Angular] 新的流程控制语法(取代 *ngFor):它为从父组件接收到的每个医生重复一个 <option>。track doctor.[id] 告诉 [Angular] 在重绘时如何识别已经显示过的医生;
- 第 17 行:[[disabled]=“selectedDoctorId() === null”] ——只要没有选择医生,按钮就保持禁用,以防止不完整的搜索;
- 第 4、6、13、18 行:[{{ ‘…’ | translate }}] ——该组件的四个静态标签(“Doctor”、“-- choose a doctor --”、“Day”、“View schedule”),通过 | translate 管道进行翻译(见上文的 [LanguageService])。而每位医生的姓名(第 8 行)则直接来自服务器数据,从不翻译。
6.10.5. src/app/features/schedule/schedule.component.ts
显示某位医生在指定日期的日程:其时间段列表,每个时间段要么可预约(“Book”按钮),要么已被预约(患者姓名 + “Cancel”按钮)。相当于原 AngularJS 1.x 客户端中的示例 8 和 9。
| import { Component, input, output } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';
@Component({
selector: 'app-schedule',
imports: [TranslatePipe],
templateUrl: './schedule.component.html',
styleUrl: './schedule.component.css',
})
export class ScheduleComponent {
readonly schedule = input<DoctorDaySchedule | null>(null);
readonly canEdit = input<boolean>(true);
readonly book = output<SlotJson>();
readonly cancel = output<AppointmentJson>();
formatTime(h: number, m: number): string {
return `${h}:${m.toString().padStart(2, '0')}`;
}
onSlotClick(scheduleSlot: ScheduleSlot): void {
if (!this.canEdit()) {
return;
}
if (scheduleSlot.appointment === null) {
this.book.emit(scheduleSlot.slot);
} else {
this.cancel.emit(scheduleSlot.appointment);
}
}
}
|
我们来解读这段代码:
- 第 12 行:[readonly schedule = input<DoctorDaySchedule | null>(null);] ——不带`.required` 的 `input()` 允许设置默认值(这里是 `null`):在执行搜索之前它一直是 `null`;
- 第 14 行:[readonly canEdit = input<boolean>(true);] ——身份验证引入的新特性:默认为 true(角色 ADMIN);[App] 向它传入 auth.isAdmin()(见 [app.html])。当设置为 false(角色 USER)时,“Book”/“Cancel”按钮会从模板中消失(见下文)——日历仍可查看,但处于只读模式;
- 第 23–26 行:[onSlotClick(scheduleSlot: ScheduleSlot): void { if (!this.canEdit()) { return; } … }] ——这个应用内的守卫与模板中隐藏按钮的做法是冗余的(角色 USER 永远看不到这个按钮):不过它能防止对该方法的程序化调用,并将意图与其余逻辑记录在同一处。提醒:无论如何,服务器([RolesGuard],第 3 章)仍然是唯一真正的保障——经过手动修改的 [Angular] 客户端也无法绕过这一限制;
- 第 27–31 行:[if (scheduleSlot.appointment === null) { this.book.emit(…); } else { this.cancel.emit(…); }] ——如果时间段可预约,则提示用户预约它;如果时间段已被预约,则提示用户取消现有预约。该组件自身不进行任何 HTTP 调用:它显示收到的数据,并将用户的意图通知其父组件。
6.10.6. src/app/features/schedule/schedule.component.html
| @if (schedule(); as currentSchedule) {
<div class="card p-3">
<h5>{{ 'SCHEDULE.TITLE_PREFIX' | translate }} {{ currentSchedule.day }} - {{ currentSchedule.doctor.title }} {{ currentSchedule.doctor.firstName }} {{ currentSchedule.doctor.lastName }}</h5>
<table class="table table-hover align-middle">
<thead>
<tr><th>{{ 'SCHEDULE.COLUMN_SLOT' | translate }}</th><th>{{ 'SCHEDULE.COLUMN_STATUS' | translate }}</th><th></th></tr>
</thead>
<tbody>
@for (scheduleSlot of currentSchedule.slots; track scheduleSlot.slot.id) {
<tr [class.free-slot]="scheduleSlot.appointment === null">
<td>{{ formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute) }} - {{ formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute) }}</td>
<td>
@if (scheduleSlot.appointment === null) {
<span class="badge text-bg-success">{{ 'SCHEDULE.FREE' | translate }}</span>
} @else {
<span class="badge text-bg-secondary">{{ scheduleSlot.appointment.client?.title }} {{ scheduleSlot.appointment.client?.firstName }} {{ scheduleSlot.appointment.client?.lastName }}</span>
}
</td>
<td>
@if (canEdit()) {
<button type="button" class="btn btn-sm" [class.btn-outline-success]="scheduleSlot.appointment === null"
[class.btn-outline-danger]="scheduleSlot.appointment !== null" (click)="onSlotClick(scheduleSlot)">
{{ scheduleSlot.appointment === null ? ('SCHEDULE.BOOK' | translate) : ('SCHEDULE.CANCEL_APPOINTMENT' | translate) }}
</button>
}
</td>
</tr>
}
</tbody>
</table>
</div>
} @else {
<p class="text-muted">{{ 'SCHEDULE.EMPTY_STATE' | translate }}</p>
}
|
我们来解读这段代码:
- 第 1 行:[@if (schedule(); as currentSchedule) {]——@if 和 @for 是 [Angular] 中新的流程控制语法:它们分别取代 *ngIf 和 *ngFor,并且是模板语言本身的一部分(无需导入模块)。as currentSchedule 将非空值捕获到一个模板变量中,避免此后到处重复书写 `schedule()!`;
- 第 14–18 行:[@if (scheduleSlot.appointment === null) { ... } @else { ... }] ——绿色的 Bootstrap 徽章(“Free”/“Libre”)或灰色徽章(患者姓名),取决于时间段的状态;
- 第 21 行:[@if (canEdit()) {] ——身份验证引入的新特性:对于 USER 角色(此时 canEdit() 为 false),“Book”/“Cancel”按钮在 DOM 中根本不存在——不仅仅是变灰或被禁用,而是完全不存在;
- 第 24 行:[{{ scheduleSlot.appointment === null ? (‘SCHEDULE.BOOK’ | translate) : (‘SCHEDULE.CANCEL_APPOINTMENT’ | translate) }}] ——管道可以用在任何模板表达式中,包括三元运算符,只要每个分支都正确加上括号。
6.10.7. src/app/features/booking-dialog/booking-dialog.component.ts
用于选择患者以预约可用时间段的(模态)窗口。相当于原 AngularJS 1.x 客户端中的示例 9。
| import { Component, input, output, signal } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { Client, SlotJson } from '../../core/models/appointment.models';
@Component({
selector: 'app-booking-dialog',
imports: [TranslatePipe],
templateUrl: './booking-dialog.component.html',
styleUrl: './booking-dialog.component.css',
})
export class BookingDialogComponent {
readonly open = input.required<boolean>();
readonly slot = input<SlotJson | null>(null);
readonly clients = input.required<Client[]>();
readonly confirm = output<{ clientId: number }>();
readonly close = output<void>();
readonly selectedClientId = signal<number | null>(null);
onClientChange(event: Event): void {
const value = (event.target as HTMLSelectElement).value;
this.selectedClientId.set(value === '' ? null : Number(value));
}
onConfirmClick(): void {
const clientId = this.selectedClientId();
if (clientId === null) {
return;
}
this.confirm.emit({ clientId });
this.selectedClientId.set(null);
}
onCloseClick(): void {
this.selectedClientId.set(null);
this.close.emit();
}
}
|
我们来解释这段代码:
- 第 12 行:[readonly open = input.required<boolean>();] ——该组件始终存在于父模板([App])中:此输入通过 [@if](见下面的模板)控制它是否显示;
- 第 26–33 行:[onConfirmClick(): void { … this.confirm.emit({ clientId }); this.selectedClientId.set(null); }] ——将所选患者的 ID 传给 [App],由 App 随后调用 AppointmentService.addAppointment(...);selectedClientId 被重置,以便下次打开窗口时使用;
- 第 35–38 行:[onCloseClick(): void { … this.close.emit(); }] ——如果用户取消,父组件只需关闭窗口,无需调用服务器。
6.10.8. src/app/features/booking-dialog/booking-dialog.component.html
该组件现在使用真正的 Bootstrap 模态类(.modal、.modal-dialog、.modal-content、.modal-backdrop……),但其可见性仍由 [Angular]([@if] (open()))控制,而不是由 Bootstrap 的 JavaScript(bootstrap.bundle.js、new bootstrap.Modal(...))控制。
| @if (open()) {
<div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title">{{ 'BOOKING_DIALOG.TITLE' | translate }}</h5>
<button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate" (click)="onCloseClick()"></button>
</div>
<div class="modal-body">
@if (slot(); as currentSlot) {
<p>{{ 'BOOKING_DIALOG.SLOT_FROM' | translate }} {{ currentSlot.startHour }}:{{ currentSlot.startMinute.toString().padStart(2, '0') }}
{{ 'BOOKING_DIALOG.SLOT_TO' | translate }} {{ currentSlot.endHour }}:{{ currentSlot.endMinute.toString().padStart(2, '0') }}</p>
}
<label class="form-label" for="select-client">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}</label>
<select id="select-client" class="form-select" (change)="onClientChange($event)">
<option value="">{{ 'BOOKING_DIALOG.CHOOSE_PATIENT' | translate }}</option>
@for (client of clients(); track client.id) {
<option [value]="client.id">{{ client.title }} {{ client.firstName }} {{ client.lastName }}</option>
}
</select>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-secondary" (click)="onCloseClick()">{{ 'BOOKING_DIALOG.CANCEL' | translate }}</button>
<button type="button" class="btn btn-primary" [disabled]="selectedClientId() === null" (click)="onConfirmClick()">
{{ 'BOOKING_DIALOG.CONFIRM' | translate }}
</button>
</div>
</div>
</div>
</div>
}
|
我们来分析这段代码:
- 第 2 行:[] ——使页面其余部分变暗的半透明背景——这里是硬编码的,而 Bootstrap 通常会在显示模态窗口时通过 JavaScript 自行插入它;
- 第 4 行:[<div class=“modal fade show d-block” …>] ——d-block 取代了通常由 Bootstrap 的 JavaScript 承担的作用(在打开时添加 `display:block`)——在这里,由第 1 行的 [@if] 直接承担这一作用;
- 第 6–10、12–24、26–31 行:[.modal-content / .modal-header / .modal-body / .modal-footer] ——Bootstrap 模态窗口的标准结构(包含标题和关闭按钮的页眉、正文、包含操作按钮的页脚);
- 第 9 行:[[attr.aria-label]=“‘BOOKING_DIALOG.CLOSE_ARIA’ | translate”] ——标准的 Bootstrap 关闭按钮(.btn-close),与模态页脚中“Cancel”按钮(第 27 行)使用同一个事件处理程序;它的无障碍文本(aria-label)通过属性绑定 ([attr.xxx])设置,而不是简单的 {{ }} 插值,当 HTML 属性的值不是静态文本时,这是唯一可行的语法。
为什么不使用 Bootstrap 的 JavaScript?因为那样 Bootstrap 和 [Angular] 将各自独立地管理同一信息(模态窗口是否打开?)——这是 Angular 应用中产生隐蔽 bug 的典型根源。让 open()(一个信号,因而是 [Angular] 的状态)单独控制显示,我们就拥有了唯一的数据来源,同时保持 Bootstrap 模态窗口完全一致的视觉外观。原始文档(2014 年)使用的是 angular-ui-bootstrap 库中的组件(AngularJS 1.x 的“开箱即用”模态窗口),它已经遵循了同样的原则:状态由 [Angular] 管理,外观借用自 Bootstrap。
6.11. 根组件 [App]:协调者与身份验证守门人
该组件扮演原 AngularJS 1.x 应用中“主控制器”的角色:它维护应用的全局状态,并响应 features/ 组件的事件,在适当的时候调用 [AppointmentService]。自从加入身份验证之后,它又承担了第二个角色:表示层的“守门人”,决定显示登录界面还是应用的其余部分。

6.11.1. src/app/app.ts
| import { Component, DestroyRef, effect, inject, signal } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { TranslatePipe } from '@ngx-translate/core';
import { AppointmentService } from './core/services/appointment.service';
import { SettingsService } from './core/services/settings.service';
import { AuthService } from './core/services/auth.service';
import { LanguageService } from './core/services/language.service';
// ……模型、组件(参见该文件的详细导入)
@Component({
selector: 'app-root',
imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],
templateUrl: './app.html',
styleUrl: './app.css',
})
export class App {
private readonly appointmentService = inject(AppointmentService);
private readonly destroyRef = inject(DestroyRef);
protected readonly settings = inject(SettingsService);
protected readonly auth = inject(AuthService);
protected readonly language = inject(LanguageService);
protected readonly doctors = signal<Doctor[]>([]);
protected readonly clients = signal<Client[]>([]);
protected readonly schedule = signal<DoctorDaySchedule | null>(null);
protected readonly error = signal<string | null>(null);
protected readonly slotBeingBooked = signal<SlotJson | null>(null);
private lastDoctorId: number | null = null;
private lastDay: string | null = null;
constructor() {
effect(() => {
if (this.auth.isLoggedIn()) {
this.loadInitialLists();
}
});
}
private loadInitialLists(): void {
this.appointmentService.getAllDoctors().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
next: (doctors) => this.doctors.set(doctors),
error: (err) => this.error.set(String(err.message ?? err)),
});
this.appointmentService.getAllClients().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
next: (clients) => this.clients.set(clients),
error: (err) => this.error.set(String(err.message ?? err)),
});
}
onLogout(): void {
this.auth.logOut();
this.doctors.set([]);
this.clients.set([]);
this.schedule.set(null);
this.error.set(null);
this.slotBeingBooked.set(null);
this.lastDoctorId = null;
this.lastDay = null;
}
onSearchSchedule(criteria: { doctorId: number; day: string }): void {
this.error.set(null);
this.lastDoctorId = criteria.doctorId;
this.lastDay = criteria.day;
this.loadSchedule();
}
onBookingRequest(slot: SlotJson): void {
this.slotBeingBooked.set(slot);
}
onConfirmBooking(choice: { clientId: number }): void {
const slot = this.slotBeingBooked();
if (slot === null || this.lastDay === null) {
return;
}
this.appointmentService.addAppointment(this.lastDay, choice.clientId, slot.id)
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe({
next: () => { this.slotBeingBooked.set(null); this.loadSchedule(); },
error: (err) => this.error.set(String(err.message ?? err)),
});
}
onCloseBooking(): void {
this.slotBeingBooked.set(null);
}
onCancelAppointment(appointment: AppointmentJson): void {
this.appointmentService.deleteAppointment(appointment.id).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
next: () => this.loadSchedule(),
error: (err) => this.error.set(String(err.message ?? err)),
});
}
private loadSchedule(): void {
if (this.lastDoctorId === null || this.lastDay === null) {
return;
}
this.appointmentService.getDoctorScheduleOfDay(this.lastDoctorId, this.lastDay)
.pipe(takeUntilDestroyed(this.destroyRef))
.subscribe({
next: (schedule) => this.schedule.set(schedule),
error: (err) => this.error.set(String(err.message ?? err)),
});
}
}
|
我们来解释这段代码:
- 第 12 行:[imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],] ——独立组件声明其模板中使用的组件和管道——为身份验证新增了 [LoginComponent],为翻译新增了 [TranslatePipe];
- 第 20 行:[protected readonly auth = inject(AuthService);] ——暴露给模板(protected,而非 private),用于角色/姓名徽章和注销按钮(见 [app.html]);
- 第 21 行:[protected readonly language = inject(LanguageService);] ——暴露给模板,用于导航栏中的 FR/EN 两个按钮,与界面的其余部分不同,这两个按钮始终可见(包括在登录界面上);
- 第 33 行:[effect(() => { if (this.auth.isLoggedIn()) { this.loadInitialLists(); } });] ——每当其监视的信号发生变化时,`effect()` 就会重新执行其函数体——此处监视的是 isLoggedIn()。它还会立即运行一次:如果 localStorage 中已存有会话(页面重新加载),列表会在启动时直接加载,而无需等待重新登录;
- 第 40 行:[private loadInitialLists(): void {] ——当用户变为已登录状态(登录成功或会话恢复)时,医生和客户列表一次性加载完毕——这相当于 [ApplicationModelService] 在服务器启动时所做工作(第 3 章)的客户端版本。由于所有服务器端点现在都受 [JwtAuthGuard] 保护,在登录之前发出这个调用毫无意义(还会导致 401 错误);
- 第 51 行:[onLogout(): void {] ——响应“Log out”按钮:清除会话以及所有显示的业务状态(第 53–59 行)——否则,随后登录的新用户会短暂看到上一个用户的日历;
- 第 41、45 行等:[.pipe(takeUntilDestroyed(this.destroyRef))] ——RxJS 订阅(.subscribe(...))会一直保持活动,直到被显式取消订阅;这是一个常见的疏忽,也是内存泄漏的来源。该运算符会在组件被销毁时自动取消订阅;
- 第 69 行:[onBookingRequest(slot: SlotJson): void { this.slotBeingBooked.set(slot); }] ——尚未调用服务器:它只是打开预约窗口。真正调用 addAppointment 的是 onConfirmBooking(第 73 行),由 [BookingDialogComponent] 的 (confirm) 事件触发;
- 第 81、92 行:[this.loadSchedule();] ——预约或取消成功后,会再次调用 loadSchedule():这样显示的日历可以立即反映新的状态,而无需用户刷新页面。
6.11.2. src/app/app.html
| <div class="container py-4">
<nav class="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
<span class="navbar-brand mb-0">{{ 'APP.TITLE' | translate }}</span>
<div class="d-flex align-items-center gap-2">
<div class="btn-group btn-group-sm" role="group" aria-label="FR / EN">
<button type="button" class="btn"
[class.btn-light]="language.currentLanguage() === 'fr'"
[class.btn-outline-light]="language.currentLanguage() !== 'fr'"
(click)="language.changeLanguage('fr')">FR</button>
<button type="button" class="btn"
[class.btn-light]="language.currentLanguage() === 'en'"
[class.btn-outline-light]="language.currentLanguage() !== 'en'"
(click)="language.changeLanguage('en')">EN</button>
</div>
@if (auth.isLoggedIn()) {
<span class="badge text-bg-light text-primary">{{ auth.role() }}</span>
<span class="text-white">{{ auth.name() }}</span>
<button type="button" class="btn btn-sm btn-outline-light" (click)="onLogout()">
{{ 'APP.LOGOUT' | translate }}
</button>
}
</div>
</nav>
<div class="row g-2 align-items-center mb-4">
<div class="col-auto"><label class="form-label mb-0" for="input-server-url">{{ 'APP.SERVER_URL_LABEL' | translate }}</label></div>
<div class="col-sm-4">
<input id="input-server-url" type="text" class="form-control form-control-sm"
[value]="settings.apiBaseUrl()" (change)="settings.setApiBaseUrl($any($event.target).value)">
</div>
</div>
@if (error(); as errorMessage) {
<div class="alert alert-danger" role="alert">{{ errorMessage }}</div>
}
@if (!auth.isLoggedIn()) {
<app-login />
} @else {
<app-doctor-day-picker [doctors]="doctors()" (search)="onSearchSchedule($event)" />
<app-schedule
[schedule]="schedule()"
[canEdit]="auth.isAdmin()"
(book)="onBookingRequest($event)"
(cancel)="onCancelAppointment($event)"
/>
<app-booking-dialog
[open]="slotBeingBooked() !== null"
[slot]="slotBeingBooked()"
[clients]="clients()"
(confirm)="onConfirmBooking($event)"
(close)="onCloseBooking()"
/>
}
</div>
|
我们来分析这段代码:
- 第 2 行:[] ——用于应用页眉的 Bootstrap 类:彩色横幅(bg-primary)、浅色文字(navbar-dark),以及内容的自动水平对齐;
- 第 3 行:[{{ ‘APP.TITLE’ | translate }}] ——`translate` 管道([@ngx-translate/core])的第一个示例:不使用硬编码的英文文本,而是使用一个键(APP.TITLE),在当前语言的字典(public/i18n/fr.json 或 en.json)中解析;
- 第 6–15 行:[<div class=“btn-group btn-group-sm” …> … FR … EN … ] ——语言选择器,始终可见(登录前后都是如此,与角色徽章不同):两个组合在一起的 Bootstrap 按钮(btn-group),根据当前语言(language.currentLanguage())其中一个高亮显示(btn-light 而非 btn-outline-light),点击按钮会调用 language.changeLanguage('fr' | 'en');
- 第 17–23 行:[@if (auth.isLoggedIn()) { ... badge + name + logout button ... }] ——此代码块仅在登录后出现;auth.[role]() 填充 Bootstrap 徽章(text-bg-light badge),auth.[name]() 显示用户姓名,按钮文本同样经过 | translate(键 APP.LOGOUT);
- 第 28 行:[{{ ‘APP.SERVER_URL_LABEL’ | translate }}] ——与标题相同的机制,应用于“Server URL”字段的标签;
- 第 27–33 行:[Server URL] ——在登录前后都保持显示(即使在尝试登录之前,也可用于指向另一个服务器 [NestJS]);
- 第 39 行:[@if (!auth.isLoggedIn()) { <app-login /> } @else { ... }] ——[App]“守门人”角色的核心:只要用户未登录,除登录界面外什么也不显示——既没有医生/日期选择器,也没有日历,更没有预约窗口;
- 第 46 行:[[canEdit]=“auth.isAdmin()”] ——根据已登录用户是否有权预约/取消(角色 ADMIN)或没有(角色 USER,只读),向 [ScheduleComponent] 传递控制权;
- 第 51–57 行:[<app-booking-dialog … />] ——始终存在于 DOM 中(与加入身份验证之前一样):其可见性由它的 open 输入控制。
请注意,语言选择器位于 [@if] 代码块(auth.isLoggedIn())之外:它必须从登录界面起就可用,即在签发任何 JWT 令牌之前——事实上,下面的截图(“[Login] 界面”)展示的正是在这个界面上切换为法语。
6.12. 应用程序分步使用指南
以下截图是在编写本文档时,使用一份填充了演示数据的服务器测试副本截取的(3 位医生,包括 Marie PELISSIER 女士;4 位客户,包括 Brigitte BISTROU;以及 admin/admin 和 user/user 两个账户)。
6.12.1. 1. 登录界面
在用户登录之前,只显示登录界面——应用的其余部分(医生/日期选择器、日历)尚不会出现在页面上。不过页眉中的“FR”和“EN”两个按钮在此阶段已经可用——更改语言不需要令牌:

登录界面
使用错误密码尝试登录时,会显示一条不带更多细节的错误信息(以避免泄露问题出在用户名还是密码上):

登录错误
点击“FR”会立即翻译界面,包括更改语言时恰好正在显示的这条错误信息——这是本章前面(login.component.ts 一节)所解释的选择的直接结果,即在 error() 中存储一个翻译键,而不是已经解析好的英文文本:

法语登录界面
6.12.2. 2. 以管理员身份登录(角色 ADMIN)
使用 admin/admin 账户登录后,页眉会显示角色(“ADMIN”徽章)和用户姓名,以及一个“Log out”按钮。医生/日期选择器出现,与加入身份验证之前一样:

以 ADMIN 身份登录后的主页
登录后法语界面仍然可用;此时它还会翻译角色徽章、标签名称和“Log out”按钮:

以 ADMIN 身份登录后的主页(法语)
选择医生并点击“View schedule”后,每个可用时间段都有一个“Book”按钮,每个已预约的时间段都有一个“Cancel”按钮:ADMIN 角色拥有完全的访问权限,与加入角色之前完全一样:

日历,ADMIN 视图(可见 Book/Cancel 按钮)
点击“Book”会打开 Bootstrap 模态窗口,提示您选择一位患者:

预约窗口(Bootstrap 模态窗口)
选择患者并点击“Confirm”后,窗口关闭,日历自动刷新:已预约的时间段现在显示为已占用,并带有所选患者的姓名:

预约后的日历
点击“Cancel”(当该时间段已被预约时)会以同样的方式刷新日历——该时间段恢复为“Free”:

取消后的日历
6.12.3. 3. 以用户身份登录(角色 USER,只读)
注销后,使用 user/user 账户登录会显示不同的“USER”徽章:

以 USER 身份登录后的主界面
日历仍然可以查看,但不会出现“Book”/“Cancel”按钮:每个时间段的操作列都是空的。直接向服务器发出的请求(例如使用 Postman 并提供该用户的令牌)仍然会收到 403 Forbidden 响应——隐藏按钮只是为了显示上的便利;真正的限制由服务器端的 [RolesGuard] 强制执行(第 3 章):

日历,USER 视图(只读,没有操作按钮)
6.13. 尚未涉及或推迟的内容
原 AngularJS 1.x 客户端的“调试”模式(显示当前视图的原始模板)是一个被有意省略的特性——它不会在课程的后续阶段出现(该决定的理由见第 6 章结论)。不过,设置人为的网络延迟确实被推迟到了后续阶段。