Skip to content

6. 第 5 章 - [RdvMedecins] 应用的 [Angular] 客户端

本章逐个文件地详细讲解本文档随附的 [rdvmedecins-angular-client] 文件夹的内容,采用本课程一贯的格式:逐行编号的源代码,随后是标题为“我们来解读这段代码:”的小节。每个项目文件夹还包含其自己的 README.md 文件。

6.1. 架构概览

与原文档一样,客户端采用分层架构,在此我们称之为V-C-Services(视图-控制器-服务):

Image

术语上有一点差异值得注意:在 AngularJS 1.x 中,视图(HTML 模板)和控制器(相关联的 JavaScript 类)是两个独立的实体,通过 $scope 相连。在 [Angular] 中,它们合并为一个实体,即组件(见上一章)——因此,在后文中,凡是原文档区分视图和控制器的地方,我们都将简单地称为“组件”。

与原文档一样,组件绝不直接与服务器通信:这一职责专属于服务层。这是一条同时适用于 AngularJS 1.x 和 [Angular] 的设计原则——它没有改变。

6.2. 项目树

Image

该结构直接遵循原文档的流程(登录、选择医生/日期、查看日程、预约),只是在这里组织成了独立的 [Angular] 组件,而不是分开的 AngularJS 1.x 控制器和视图。

Bootstrap用于所有视图([node_modules/bootstrap/dist/css/bootstrap.min.css],在 angular.json 中声明)——这是对 Bootstrap 3 的直接演进,原文档已经使用了 Bootstrap 3。

6.3. 项目配置文件

Image

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. 启动应用

Image

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]

1
2
3
4
5
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 层

Image

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

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

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

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

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

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

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

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

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

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

我们来解读这段代码:

  • 第 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 层

Image

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 管道查询(见本章后文)。

Image

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 层

Image

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. 应用配置

Image

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

1
2
3
import { Routes } from '@angular/router';

export const routes: Routes = [];

我们来解读这段代码:

  • 第 3 行:[export const routes: Routes = [];] ——路由表保持为空:应用只有一个页面(根组件 [App] 根据 AuthService.isLoggedIn() 显示登录屏幕,或者显示医生/日期选择器 + 日历 + 预约窗口)。我们本可以创建一个 /login 路由来代替条件显示,但对于单页应用来说,这种变通做法毫无意义。

6.10. features 层:四个组件

Image

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]。自从加入身份验证之后,它又承担了第二个角色:表示层的“守门人”,决定显示登录界面还是应用的其余部分。

Image

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”两个按钮在此阶段已经可用——更改语言不需要令牌:

Image

登录界面

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

Image

登录错误

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

Image

法语登录界面

6.12.2. 2. 以管理员身份登录(角色 ADMIN)

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

Image

以 ADMIN 身份登录后的主页

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

Image

以 ADMIN 身份登录后的主页(法语)

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

Image

日历,ADMIN 视图(可见 Book/Cancel 按钮)

点击“Book”会打开 Bootstrap 模态窗口,提示您选择一位患者:

Image

预约窗口(Bootstrap 模态窗口)

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

Image

预约后的日历

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

Image

取消后的日历

6.12.3. 3. 以用户身份登录(角色 USER,只读)

注销后,使用 user/user 账户登录会显示不同的“USER”徽章:

Image

以 USER 身份登录后的主界面

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

Image

日历,USER 视图(只读,没有操作按钮)

6.13. 尚未涉及或推迟的内容

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