Skip to content

6. Capítulo 5 - El cliente [Angular] de la aplicación [RdvMedecins]

Este capítulo detalla, archivo por archivo, el contenido de la carpeta [rdvmedecins-angular-client] incluida con este documento, con el formato adoptado en todo este curso: código fuente numerado línea por línea, seguido de una sección titulada “Comentemos este código:”. Cada carpeta de proyecto contiene además su propio archivo README.md.

6.1. Visión general de la arquitectura

Como en el documento original, el cliente sigue una arquitectura en capas, que aquí llamaremos V-C-Services (Vista-Controlador-Servicios):

Image

Conviene señalar una diferencia de terminología: en AngularJS 1.x, la vista (la plantilla HTML) y el controlador (la clase JavaScript asociada) eran dos entidades distintas, vinculadas por $scope. En [Angular], se combinan en una sola entidad, el componente (véase el capítulo anterior); por eso, en lo sucesivo hablaremos simplemente de “componentes” donde el documento original distinguía entre vista y controlador.

Como en el documento original, los componentes NUNCA se comunican directamente con el servidor: este papel está reservado exclusivamente a la capa de servicios. Es un principio de diseño que se aplica por igual a AngularJS 1.x y a [Angular]; no ha cambiado.

6.2. Árbol del proyecto

Image

Esta estructura sigue directamente el flujo del documento original (inicio de sesión, selección de médico/día, consulta de la agenda, solicitud de una cita), organizado aquí simplemente en componentes standalone de [Angular] en lugar de controladores y vistas separados de AngularJS 1.x.

Bootstrap se usa en todas las vistas ([node_modules/bootstrap/dist/css/bootstrap.min.css], declarado en angular.json); es una evolución directa de Bootstrap 3, que ya usaba el documento original.

6.3. Archivos de configuración del proyecto

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

Comentemos este código:

  • líneas 4–10: [“scripts”: { … }] — los comandos `npm run <name>` disponibles. `start` (`ng serve`) lanza el servidor de desarrollo con recarga automática cada vez que se modifica un archivo fuente; es el comando que se usa en todo este documento;
  • líneas 13–25: [“dependencies”: { … }] — los paquetes necesarios para ejecutar la aplicación en el navegador: el núcleo de [Angular] ([@angular/core], [@angular/common], [@angular/compiler], [@angular/forms], [@angular/platform-browser], [@angular/router]), Bootstrap (solo la hoja de estilos; véase angular.json), RxJS (los Observables que usa [HttpClient]) y, introducidos en este capítulo, [@ngx-translate/core] y [@ngx-translate/http-loader], la biblioteca de terceros utilizada para la traducción FR/EN de la interfaz (véanse [LanguageService] y app.config.ts más abajo);
  • líneas 26–32: [“devDependencies”: { … }] — paquetes necesarios solo durante el desarrollo (CLI, compilador), que nunca se incluyen en el paquete final entregado al navegador: @angular/cli/@angular/build (la CLI y su motor de compilación), [@angular/compiler-cli] (compilación de plantillas anticipada o AOT), TypeScript y Prettier (formateo automático del código, que no se usa en este documento pero se incluye de forma predeterminada en todo proyecto [Angular] generado).

A diferencia del servidor [NestJS] (módulos commonjs, véase el Capítulo 3), un proyecto [Angular] predeterminado se ejecuta como módulos ECMAScript nativos (import/export); esto se refleja más abajo en "module": "preserve" de tsconfig.json.

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

Comentemos este código (se condensaron algunas líneas más arriba para facilitar la lectura; el archivo entregado está completo):

  • línea 11: [“prefix”: “app”,] — el prefijo aplicado al selector de cada componente del proyecto (app-login, app-schedule, etc.); una convención, verificada por el compilador, que evita colisiones de nombres con posibles componentes de terceros;
  • línea 16: [“browser”: “src/main.ts”,] — el punto de entrada de la compilación; el mismo archivo que se explica más adelante en este capítulo;
  • líneas 18–20: [“assets”: [ { “glob”: “**/*”, “input”: “public” } ],] — copia todo el contenido de la carpeta public/, tal cual, en la raíz de la aplicación compilada; este mecanismo es lo que permite que public/i18n/fr.json sea accesible en la URL /i18n/fr.json, la dirección que consulta TranslateHttpLoader (véase más adelante en este capítulo);
  • líneas 21–24: [“styles”: [ “node_modules/bootstrap/dist/css/bootstrap.min.css”, “src/styles.css” ],] — las hojas de estilo globales, concatenadas en este orden en tiempo de compilación: primero Bootstrap (para que nuestras propias reglas, en [styles.css], puedan sobrescribirlo si es necesario), sin recurrir a una instrucción @import estándar de CSS.

Este archivo no tiene equivalente en el proyecto original con AngularJS 1.x (las herramientas de compilación de la época, Grunt y Gulp, se configuraban por separado); en el proyecto [NestJS] (Capítulo 3), nest-cli.json cumple una función similar, pero de manera más sencilla.

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" }
   ]
 }

Analicemos este código:

  • línea 4: [“strict”: true,] — a diferencia del servidor [NestJS] (que solo habilita strictNullChecks de forma aislada; véase el Capítulo 3), el cliente habilita el modo estricto completo de TypeScript: toda variable debe tener un tipo determinable y todo valor null/undefined debe tratarse explícitamente. Es una elección más exigente, coherente con el hecho de que este documento presenta [Angular] como la referencia de las “mejores prácticas actuales”;
  • línea 20: [“strictTemplates”: true]—la opción más importante de este archivo: extiende la verificación de tipos de TypeScript a las plantillas HTML mismas ([app.html], schedule.component.html…). Un error como {{ doctor.lastNamee }} (errata) o [canEdit]="auth.isAdmin" (faltan los paréntesis) se señala entonces durante la compilación, igual que un error en un archivo .ts; esto no ocurría en AngularJS 1.x (2014), donde una plantilla así se compilaba siempre y el error solo se hacía evidente en tiempo de ejecución (de forma silenciosa, la mayoría de las veces);
  • Líneas 22–25: [“files”: [], “references”: [ { “path”: “./tsconfig.app.json” } ]] — este archivo raíz no compila directamente ningún archivo ("files": []): delega en tsconfig.app.json (más abajo) mediante el mecanismo de referencias de proyectos de TypeScript, que permite que un único proyecto [Angular] defina finalmente varias configuraciones de compilación distintas (aplicación, pruebas, etc.) que comparten una base común.

6.3.4. tsconfig.app.json

{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "outDir": "./out-tsc/app",
    "types": []
  },
  "include": [
    "src/**/*.ts"
  ],
  "exclude": [
    "src/**/*.spec.ts"
  ]
}

Comentemos este código:

  • línea 2: [“extends”: “./tsconfig.json”,] — se apoya en la base común (modo estricto, target ES2022…) en lugar de redefinirlo todo;
  • línea 8: [“src/**/*.ts”] — todos los archivos .ts del proyecto, incluido (por ejemplo) language.service.ts, añadido en este capítulo;
  • línea 11: [“src/**/*.spec.ts”] — los archivos de pruebas unitarias (no presentes en este proyecto, pero excluidos por convención) se compilan por separado, con su propia configuración; no se tratan en este documento.

6.4. Arranque de la aplicación

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>

Comentemos este código:

  • línea 2: [<html lang="en">] — el idioma predeterminado de la página, útil para la accesibilidad y los motores de búsqueda. Como esta página HTML es estática (el navegador la carga ANTES de que se inicie la aplicación [Angular]), obviamente no puede reflejar de inmediato una elección de idioma que el usuario haga después; es [LanguageService] (véase más abajo) quien actualiza dinámicamente este atributo en cuanto el usuario cambia a francés;
  • línea 11: [] — el selector del componente raíz ([App], véase app.ts: selector: 'app-root'): es el único elemento que contiene la página inicialmente, y [Angular] lo rellena por completo una vez que arranca. Sigue exactamente el mismo principio que AngularJS 1.x (2014), que colocaba ng-app="rdvmedecinsApp" en la etiqueta <html> del archivo [app.html] del proyecto original: una página HTML casi vacía, controlada por completo por el framework de 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));

Comentemos este código:

  • línea 5: [bootstrapApplication(App, appConfig).catch((err) => console.error(err));] — inicia la aplicación especificando el componente raíz ([App]) y su configuración (appConfig; véase app.config.ts más abajo); bootstrapApplication es la función de arranque de las aplicaciones [Angular] standalone (sin NgModule), que reemplaza a platformBrowserDynamic().bootstrapModule([AppModule]) de las versiones anteriores de Angular. .catch(...) captura cualquier error que se produzca durante el propio arranque (antes de que se ejecute cualquier línea del código de la aplicación); un caso lo bastante raro y grave como para merecer un tratamiento distinto del manejo de errores habitual de la aplicación.

Solo hay un punto de entrada para toda la aplicación: esta es la definición misma de una aplicación web de página única (SPA), como ya se describió en el documento original.

6.4.3. [src/styles.css]

body {
  background-color: #f5f7fa;
}

.free-slot {
  cursor: pointer;
}

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

Comentemos este código:

  • línea 1: [body { background-color: #f5f7fa; }] — un gris muy claro en lugar del blanco puro predeterminado, para que las tarjetas de Bootstrap (fondo blanco, .card) se destaquen ligeramente del fondo de la página;
  • líneas 5–10: [.free-slot] — se aplica a las filas de la tabla del calendario que representan un horario disponible (véase schedule.component.html, [class.free-slot]="scheduleSlot.appointment === null"): el cursor cambia a una mano (cursor: pointer) y el fondo se vuelve ligeramente verde al pasar el mouse, para sugerir que la fila se puede seleccionar, incluso antes de hacer clic en ella.

Este archivo contiene estilos globales, a diferencia de los estilos “locales” definidos en el archivo .css de cada componente (schedule.component.css…), que se aplican solo a la plantilla de ese componente específico. src/app/app.css, la hoja de estilos del componente raíz, permanece vacío: Bootstrap y [styles.css] bastan para todo lo que implementa este documento.

6.5. La capa 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;
 }

Comentemos este código:

  • líneas 1–4: [export interface ServerResponse { status: number; data: T | null; }] — corresponde exactamente a la clase del servidor [ServerResponse]<T> (véase el Capítulo 3): toda respuesta JSON tiene esta forma;
  • líneas 6–18: [Doctor / Client] — dos interfaces idénticas en su forma, que corresponden a las entidades [TypeORM] del mismo nombre (Capítulo 3). Recordatorio: aquí [Client] designa a un paciente, no a un “cliente HTTP”;
  • líneas 20–33: [SlotJson / AppointmentJson] — las versiones “ligeras” generadas del lado del servidor por getMapForSlot/getMapForAppointment (Capítulo 3, static.helper.ts);
  • líneas 40–44: [export interface DoctorDaySchedule { … }] — corresponde a la respuesta de GET /getDoctorScheduleOfDay/:doctorId/:day;
  • línea 46: [export type Role = ‘ADMIN’ | ‘USER’;] — una copia exacta del tipo [Role] del servidor (src/entities/user.entity.ts);
  • Líneas 48–53: [export interface LoginResult { … }] — el formato de los datos devueltos por POST /login (véase [AuthService] más abajo), una copia exacta de la interfaz del servidor del mismo nombre (auth/login-result.model.ts).

En AngularJS 1.x (2014), el JavaScript original no permitía describir de este modo el formato de datos esperado: una respuesta del servidor se trataba como un objeto cualquiera, sin que se realizara ninguna validación antes de la ejecución. Con TypeScript, un error tipográfico en el nombre de un campo se señala ahora incluso antes de ejecutar el programa, durante la compilación.

6.6. La capa 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);
    }
 }

Comentemos este código:

  • Línea 3: [@Injectable({ providedIn: 'root' })] — declara un servicio como un singleton global de la aplicación: [Angular] crea automáticamente una única instancia la primera vez que un componente la necesita; el equivalente moderno de un servicio que AngularJS 1.x declaraba con .service() o .factory();
  • Línea 5: [readonly apiBaseUrl = signal(‘http://localhost:8080’);] — signal(...) crea un valor reactivo: cualquiera que lea apiBaseUrl() en una plantilla de [Angular] será notificado automáticamente si su valor cambia; el mecanismo central de reactividad del [Angular] moderno, que reemplaza la observación ($watch/$scope.$apply) de AngularJS 1.x;
  • líneas 7–9: [setApiBaseUrl(url: string): void { this.apiBaseUrl.set(url); }] — tomado del campo “URL en el servidor” de la vista de inicio del documento original, que ya permitía al usuario modificarla desde la interfaz (útil si el servidor se ejecuta en un puerto distinto).

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

Comentemos este código:

  • línea 8: [export class AppointmentService {] — el equivalente directo del servicio DAO presentado en el capítulo “Ejemplo 6: Los servicios HTTP” del documento original (que usaba el servicio $http de AngularJS). A diferencia de una aplicación tradicional del lado del servidor, donde la capa web se comunica con la capa DAO solo a través de la capa de negocio, el cliente permite que la capa de presentación (nuestros componentes) llame directamente a este servicio; en el lado del cliente no existe una “capa de negocio” independiente;
  • línea 9: [private readonly http = inject(HttpClient);] — `inject()` es la forma moderna de obtener una dependencia en [Angular] (reemplaza la inyección tradicional por constructor);
  • Líneas 12–16: [getAllDoctors(): Observable<Doctor[]> { … }] — equivale a GET /getAllDoctors; cada método corresponde exactamente a una de las once rutas del controlador [NestJS] (Capítulo 3); de hecho, los mismos nombres aparecen en ambos lados, lo que facilita cotejar el código del servidor con el del cliente;
  • línea 44: [private extract<T>(response: ServerResponse<T>): T {] — en lugar de repetir la verificación “si status !== 0, es un error” en cada uno de los métodos públicos, la centralizamos aquí una sola vez;
  • línea 46: [throw new Error(…)] — RxJS redirige automáticamente una excepción de JavaScript lanzada en `map()` a la rama `error` de la suscripción (.subscribe({ next, error })). Este mecanismo permite que el componente raíz muestre un mensaje de error sin necesidad de conocer los detalles de la envoltura [ServerResponse]<T>.

6.6.3. src/app/core/services/auth.service.ts

El servicio que gestiona la conexión del usuario: llama a POST /login, almacena el token JWT recibido (y la identidad/rol que lo acompaña) como signals y garantiza que sobreviva a una recarga de la página mediante localStorage. Es el único otro lugar de la aplicación, junto con [AppointmentService], que se comunica con el servidor mediante HTTP; una excepción intencional a la regla del “servicio HTTP único”, que refleja, en el lado del cliente, la separación que ya se hizo en el lado del servidor entre RdvMedecinsController y 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;
   }
 }

Comentemos este código:

  • líneas 7–12: [interface StoredSession { … }] — el formato de lo que se escribe en localStorage y se lee de él: un simple objeto JSON, distinto de [LoginResult] por diseño (aunque incluye todos sus campos);
  • línea 21: [private readonly session = signal<StoredSession | null>(readStoredSession());] — se inicializa desde localStorage: si el usuario recarga la página después de iniciar sesión, sigue conectado (hasta que el token expire en el servidor o cierre sesión explícitamente);
  • línea 22: [readonly isLoggedIn = computed(() => this.session() !== null);] — `computed()` crea un signal derivado: su valor se recalcula automáticamente cada vez que cambia la sesión, y todo componente que lo lea (auth.isLoggedIn() en [app.html]) es a su vez notificado;
  • líneas 23–26: [login / name / role / isAdmin] — signals derivados, expuestos como de solo lectura a los componentes (app.ts, login.component.ts, schedule.component.ts mediante canEdit);
  • línea 28: [readonly accessToken = computed(() => this.session()?.accessToken ?? null);] — el token que debe incluirse en cada solicitud HTTP protegida, leído por auth.interceptor.ts (más abajo);
  • línea 30: [logIn(login: string, password: string): Observable {] — equivale a POST /login, con el cuerpo JSON { login, password };
  • líneas 34–39: [map((response) => { if (response.status !== 0 …) { throw …; } return response.data; })] — el mismo principio que AppointmentService.extract(), reescrito aquí en línea en lugar de como una llamada (no hay un método privado compartido entre los dos servicios, que siguen siendo independientes a propósito);
  • línea 40: [tap((result) => this.saveSession(result)),] — `tap()` realiza un efecto secundario (aquí: guardar la sesión) sin cambiar el valor que se pasa después al suscriptor, a diferencia de `map()`, que transforma ese valor;
  • líneas 44–47: [logOut(): void { this.session.set(null); localStorage.removeItem(…); }] — puramente local (sin llamada al servidor): un token JWT no se “revoca” en el lado del servidor en esta migración inicial; expira por sí solo después de JWT_EXPIRES_IN;
  • Línea 56: [function readStoredSession(): StoredSession | null {] — protegida por un bloque try/catch: localStorage puede no estar disponible (por una navegación privada muy restrictiva) o contener un valor dañado; en ese caso, simplemente se supone que no hay sesión.

6.6.4. src/app/core/services/language.service.ts

Un pequeño servicio que centraliza el cambio de idioma de la interfaz (francés/inglés). Se apoya en [TranslateService] ([@ngx-translate/core], configurado en app.config.ts más abajo) para el trabajo de traducción propiamente dicho, y añade lo que ya se encuentra en [SettingsService] y [AuthService]: un signal expuesto al resto de la aplicación y el almacenamiento de la elección del usuario en 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;
     });
   }
 }

Analicemos este código:

  • línea 10: [private readonly translate = inject(TranslateService);] — [TranslateService] es el servicio central de [@ngx-translate/core]: se encarga de cargar un diccionario de traducción y de resolver una clave ('LOGIN.TITLE') en un texto ('Login' o 'Connexion', según el idioma actual);
  • línea 12: [readonly currentLanguage = this.translate.currentLang;] — desde la versión 18 de [@ngx-translate/core], [TranslateService] ya expone currentLang como un signal de eventos: no hace falta volver a crear uno aquí, simplemente lo republicamos con este nombre, de modo que el resto del código de la aplicación (véase [app.html]) nunca necesite importar [TranslateService] directamente, sino solo [LanguageService];
  • líneas 14–19: [constructor() { const initialLanguage = …; if (…) { this.applyLanguage(initialLanguage); } }]—al arrancar: si el usuario ya había elegido un idioma en una visita anterior, se restaura; de lo contrario, se usa el francés si el navegador está en francés y, si no, se conserva el idioma predeterminado establecido en app.config.ts (inglés);
  • líneas 21–24: [changeLanguage(language: Language): void { localStorage.setItem(…); this.applyLanguage(language); }] — la llaman los dos botones FR/EN de la barra de navegación (véase [app.html]);
  • líneas 26–30: [private applyLanguage(language: Language): void { this.translate.use(language).subscribe(() => { document.documentElement.lang = language; }); }] — translate.use(language) carga (si es necesario) el archivo public/i18n/<language>.json correspondiente y luego cambia el idioma actual; es un Observable que emite una señal una vez completada la carga; aprovechamos esto para actualizar el atributo <html lang="..."> de la página (útil para la accesibilidad), que [Angular] no gestiona por sí mismo porque index.html es una página estática que se carga incluso antes de que arranque la aplicación.

Equivale al botón “FR / EN” del cliente original con AngularJS 1.x, que en su momento se basaba en la biblioteca angular-translate, la predecesora, dentro del ecosistema de AngularJS 1.x, de ngx-translate, que se usa aquí.

6.7. Diccionarios de traducción (public/i18n/)

TranslateHttpLoader ([@ngx-translate/http-loader], configurado en app.config.ts más abajo) carga uno de estos dos archivos mediante una solicitud HTTP GET [/i18n/]<language>.json, cada vez que cambia el idioma (o se usa por primera vez). [TranslateService] aplana entonces este JSON en un diccionario "LOGIN.TITLE", "SCHEDULE.FREE"… que consulta el pipe | translate usado en todas las plantillas del directorio features/ (véase más adelante en este capítulo).

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

Comentemos este código:

  • línea 1: [{] — un objeto JSON anidado, con una sección por componente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); [TranslateService] lo aplana en un diccionario plano, donde cada clave completa ("LOGIN.TITLE") se forma uniendo la ruta con puntos;
  • líneas 14–17: [“DEMO_ACCOUNTS_PREFIX” / “DEMO_ACCOUNTS_ADMIN” / “DEMO_ACCOUNTS_OR” / “DEMO_ACCOUNTS_USER”] — una frase dividida en cuatro claves en lugar de una sola: el texto completo del documento original (“Demo accounts: admin / admin (role ADMIN…) or user / user (role USER…) ”) contiene además elementos <code>admin</code> que no deben traducirse (son credenciales de inicio de sesión, idénticas en ambos idiomas); por lo tanto, deben insertarse entre los fragmentos traducidos (véase login.component.html más abajo);
  • línea 32: [“EMPTY_STATE”: “Choisissez un médecin et un jour, puis cliquez sur « Voir l’agenda ».”] — a diferencia de la mayoría de las demás claves (que son simples etiquetas), esta es una frase completa: nada impide que una clave de traducción contenga signos de puntuación o varias palabras, siempre que corresponda a un único bloque de texto en la plantilla.

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

Analicemos este código:

  • línea 3: [“TITLE”: “RdvMedecins - NestJS / Angular port”,] — solo cambia el subtítulo: “[RdvMedecins]” sigue igual en ambos idiomas; es el nombre propio de la aplicación;
  • línea 11: [“SUBMIT”: “Log in”,] — traducción adaptada en lugar de literal (“Connect” habría sido una traducción directa del francés): la terminología estándar de autenticación en inglés distingue entre “log in” (verbo, la acción de iniciar sesión) y “login” (sustantivo, el nombre de usuario ingresado; véase la línea 9, que sigue siendo “[Login]” en ambos idiomas, ya que también es el nombre del campo que espera el servidor; véase [LoginDto] en el Capítulo 3).

Ambos archivos deben seguir siendo estructuralmente idénticos (las mismas claves en los dos): así se garantiza que una clave exista en ambos idiomas. Una clave que falte en uno de los dos archivos se mostraría tal cual (su nombre sin procesar) en lugar de su traducción, hasta que se añada.

Lo que no se traduce: los mensajes de error que devuelve el servidor (véase el Capítulo 3, envoltura [ServerResponse]<T>) permanecen en inglés sea cual sea el idioma seleccionado en el lado del cliente; traducir estos mensajes requeriría internacionalización en el servidor, lo cual queda fuera del alcance de este paso (véase el Capítulo 6, Conclusión). Los nombres de los médicos y de los pacientes, en cambio, provienen directamente de la base de datos y, por supuesto, no se traducen en ningún caso.

6.8. La capa core/interceptors

Image

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

Un interceptor HTTP se inserta entre [HttpClient] y la red: intercepta cada solicitud saliente (y su respuesta) y puede modificarlas. Es el equivalente moderno de los interceptores de $http de AngularJS 1.x ya tratados en el documento original (capítulo “Ejemplo 6”); la forma ha cambiado (una simple función en lugar de un objeto con métodos request/response), pero la idea sigue siendo la misma.

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

Comentemos este código:

  • Línea 6: [export const authInterceptor: HttpInterceptorFn = (request, next) => {] — Desde hace algunas versiones, [Angular] favorece los interceptores funcionales ([HttpInterceptorFn]), una simple función, frente a los interceptores basados en clases de las versiones anteriores de [Angular]: más cortos de escribir y más simples de registrar (véase app.config.ts, withInterceptors([...]));
  • líneas 10–12: [request.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : request;] — una solicitud de [HttpClient] es un objeto inmutable: no se pueden modificar sus encabezados directamente; hay que crear una copia modificada. Es esta copia (requestWithToken) la que debe pasarse por la cadena, nunca la solicitud original sin modificar;
  • líneas 15–18: [catchError((error) => { if (error instanceof HttpErrorResponse && error.status === 401) { auth.logOut(); } … })] — un error 401 durante una sesión significa que el token ya no es válido (expiró o el servidor se reinició): el cliente se desconecta correctamente en lugar de quedar en un estado incoherente (aparentemente conectado, pero sin que ninguna solicitud tenga éxito);
  • línea 19: [return throwError(() => error);] — el error se vuelve a lanzar tal cual después de este tratamiento: el interceptor no debe ocultar el error al código que realiza la llamada ([ScheduleComponent] mediante [App], por ejemplo), sino solo manejar un caso específico de paso.

Podríamos añadir manualmente Authorization: Bearer ... a cada uno de los métodos de AppointmentService. Un interceptor evita esta repetición: la pregunta “¿cómo se autentica una solicitud?” se responde en un solo lugar, de una vez por todas, y se aplicará automáticamente a cualquier servicio futuro que use HttpClient. Se registra en app.config.ts (más abajo), mediante provideHttpClient(withInterceptors([authInterceptor])): sin esta línea, la función existiría, pero nunca se llamaría.

6.9. Configuración de la aplicación

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' }),
     }),
   ],
 };

Comentemos este código:

  • Línea 9: [export const appConfig: ApplicationConfig = {] — lo que recibe el componente raíz ([App]) para funcionar. Es un concepto propio de las aplicaciones [Angular] “standalone” (sin NgModule): cada provideXxx() activa un servicio transversal a toda la aplicación; no hay un equivalente directo de este archivo en el proyecto original con AngularJS 1.x;
  • Línea 12: [provideRouter(routes),] — activa el enrutador de Angular. Nuestra aplicación tiene una sola página: es un componente ([LoginComponent]), mostrado condicionalmente por [App], que hace de pantalla de inicio de sesión, no una ruta dedicada (véase app.routes.ts más abajo);
  • línea 13: [provideHttpClient(withInterceptors([authInterceptor])),] — activa [HttpClient], que usan [AppointmentService] y [AuthService]; el equivalente moderno del servicio $http de AngularJS 1.x. withInterceptors ([authInterceptor]) registra el interceptor de autenticación: sin esta línea, authInterceptor existiría, pero nunca se llamaría;
  • líneas 14–18: [provideTranslateService({ lang: ‘en’, fallbackLang: ‘en’, loader: provideTranslateHttpLoader({ prefix: ‘/i18n/’, suffix: ‘.json’ }), }),] — activa [@ngx-translate/core], la biblioteca utilizada para cambiar la interfaz entre francés e inglés. lang: 'en' fija el idioma de arranque ([LanguageService], véase más arriba, lo reemplazará de inmediato por la selección almacenada en localStorage, si existe, o por el francés si el navegador está en francés); fallbackLang: 'en' se usaría si faltara una clave de traducción en el diccionario del idioma actual; loader: provideTranslateHttpLoader(...) indica CÓMO cargar los diccionarios, aquí mediante una consulta HTTP GET a archivos JSON estáticos (public/i18n/fr.json, public/i18n/en.json, véase más arriba), con el prefijo y el sufijo que forman la URL completa (prefijo + idioma + sufijo, por ejemplo, /i18n/en.json).

6.9.2. src/app/app.routes.ts

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

export const routes: Routes = [];

Comentemos este código:

  • línea 3: [export const routes: Routes = [];] — la tabla de rutas permanece vacía: la aplicación cabe en una sola página (el componente raíz [App] muestra la pantalla de inicio de sesión o bien el selector de médico/día + el calendario + la ventana de reserva, según AuthService.isLoggedIn()). Podríamos haber creado una ruta /login en lugar de una visualización condicional, pero para una aplicación de página única, este rodeo no habría servido de nada.

6.10. La capa features: los cuatro componentes

Image

6.10.1. src/app/features/login/login.component.ts

La pantalla de inicio de sesión: equivale a la vista [login.html] del cliente original con AngularJS 1.x (la primera vista que muestra la aplicación).

  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');
         },
       });
   }
 }

Comentemos este código:

  • línea 8: [imports: [TranslatePipe],] — un componente standalone declara los pipes que usa en su plantilla; [TranslatePipe] ([@ngx-translate/core]) es lo que hace disponible | translate en login.component.html (más abajo);
  • Líneas 16–17: [protected readonly login = signal(’‘); protected readonly password = signal(’’);] — estado puramente local del formulario (lo que el usuario está escribiendo en ese momento);
  • línea 19: [protected readonly inProgress = signal(false);] — true durante la llamada de red: deshabilita el botón para evitar un doble clic;
  • línea 20: [protected readonly error = signal<string | null>(null);] — almacena una clave de traducción, no un texto ya traducido: el pipe | translate de la plantilla la resuelve en el momento de mostrarla;
  • línea 30: [onSubmit(): void {] — se activa con el botón “Log in” (véase la plantilla más abajo);
  • línea 40: [next: () => this.inProgress.set(false),] — no se necesita ningún otro tratamiento aquí: [AuthService] ya almacenó la sesión (signal + localStorage); es [App], que lee auth.isLoggedIn(), quien reaccionará dejando de mostrar <app-login>;
  • Líneas 41–44: [error: () => { …this.error.set(‘LOGIN.ERROR’); }] — una combinación no válida de nombre de usuario y contraseña hace que logIn() falle con un error HTTP 401 (véase el Capítulo 3, [LocalStrategy]): al usuario simplemente se le muestra 'LOGIN.ERROR' (“Incorrect login or password.” / “Login ou mot de passe incorrect.”, según el idioma), sin intentar distinguir entre un nombre de usuario inexistente y una contraseña incorrecta (por precaución, como haría cualquier aplicación real). Almacenar una clave en lugar de texto plano tiene una ventaja práctica: si el usuario cambia de idioma mientras se muestra este mensaje, se traduce solo, sin necesidad de código adicional aquí.

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>

Analicemos este código:

  • líneas 1–2: [] — clases de cuadrícula de Bootstrap: centra horizontalmente una tarjeta de ancho fijo, sea cual sea el ancho de la pantalla;
  • líneas 12–13, 18–19: [(input)=“onLoginChange($event)” (keyup.enter)=“onSubmit()”] — sin FormsModule/ngModel: los campos se leen directamente mediante el evento DOM (input), y (keyup.enter) permite enviar el formulario con el teclado, sin mouse;
  • línea 22: [[disabled]=“inProgress()”] — el botón se deshabilita durante la llamada de red (véase LoginComponent.inProgress) para evitar un doble clic mientras el primer intento sigue en curso;
  • líneas 27–28: [{{ ‘LOGIN.DEMO_ACCOUNTS_PREFIX’ | translate }} admin / admin {{ ‘LOGIN.DEMO_ACCOUNTS_ADMIN’ | translate }} …] — el texto de las cuentas de demostración alterna entre texto traducido e identificadores no traducidos (<code>admin</code>, <code>user</code>): para permitir esta mezcla, la frase se dividió en cuatro claves independientes en los diccionarios JSON (véase más arriba, public/i18n/fr.json), en lugar de una sola clave que contenga la frase completa.

6.10.3. src/app/features/doctor-day-picker/doctor-day-picker.component.ts

El componente que permite seleccionar un médico y una fecha, y luego ver su agenda. Conceptualmente equivalente a los ejemplos 7 a 10 del cliente AngularJS 1.x original.

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

Analicemos este código:

  • línea 7: [imports: [TranslatePipe],] — hace que | translate esté disponible en doctor-day-picker.component.html (más abajo);
  • línea 12: [readonly doctors = input.required<Doctor[]>();] — declara que este componente debe recibir la lista de médicos de su padre ([App]); [Angular] informa un error si este componente se usa sin que se proporcione esta entrada. input() (basado en signals) reemplaza la palabra clave heredada @Input(): [doctors]() se trata como una función, lo que permite a [Angular] saber exactamente cuándo volver a dibujar el componente;
  • línea 13: [readonly search = output<{ doctorId: number; day: string }>();] — declara el evento que este componente propaga a su padre, equivalente a un evento personalizado ($emit/$broadcast) en AngularJS 1.x;
  • líneas 15–16: [selectedDoctorId / selectedDay] — un estado propio de este componente (lo que está seleccionado en los menús, mientras el usuario no haya hecho clic en el botón); selectedDay se inicializa con la fecha de hoy;
  • líneas 27–33: [onSearchClick(): void { … this.search.emit({ doctorId, day: … }); }] — no llama a HTTP por sí mismo: simplemente transmite la intención del usuario a su padre, que decidirá si llama a 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>

Analicemos este código:

  • línea 7: [@for (doctor of doctors(); track doctor.id) {] — [@for] es la nueva sintaxis de control de flujo de [Angular] (reemplaza a *ngFor): repite un <option> por cada médico recibido del componente padre. track doctor.[id] le indica a [Angular] cómo reconocer a un médico ya mostrado si se vuelve a dibujar;
  • línea 17: [[disabled]=“selectedDoctorId() === null”] — el botón permanece deshabilitado mientras no se haya seleccionado un médico, para evitar una búsqueda incompleta;
  • líneas 4, 6, 13, 18: [{{ ‘…’ | translate }}] — las cuatro etiquetas estáticas de este componente (“Doctor,” “-- choose a doctor --,” “Day,” “View schedule”), traducidas mediante el pipe | translate (véase [LanguageService] más arriba). Sin embargo, el nombre de cada médico (línea 8) proviene directamente de los datos del servidor y nunca se traduce.

6.10.5. src/app/features/schedule/schedule.component.ts

Muestra la agenda de un médico para un día determinado: una lista de sus franjas horarias, cada una de las cuales está disponible (botón “Book”) o reservada (nombre del paciente + botón “Cancel”). Equivalente a los ejemplos 8 y 9 del cliente AngularJS 1.x original.

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

Comentemos este código:

  • línea 12: [readonly schedule = input<DoctorDaySchedule | null>(null);] — `input()` sin `.required` permite un valor predeterminado (aquí, `null`): vale `null` hasta que se realiza una búsqueda;
  • línea 14: [readonly canEdit = input<boolean>(true);] — una novedad introducida por la autenticación: es true de forma predeterminada (rol ADMIN); [App] le pasa auth.isAdmin() (véase [app.html]). Cuando vale false (rol USER), los botones “Book”/“Cancel” desaparecen de la plantilla (véase más abajo): el calendario sigue siendo visible, pero en modo de solo lectura;
  • líneas 23–26: [onSlotClick(scheduleSlot: ScheduleSlot): void { if (!this.canEdit()) { return; } … }] — esta guardia de la aplicación es redundante con el botón oculto en la plantilla (un rol USER nunca ve este botón): aun así protege contra una llamada programática a este método y documenta la intención en el mismo lugar que el resto de la lógica. Recordatorio: en cualquier caso, el servidor ([RolesGuard], capítulo 3) sigue siendo la única salvaguarda real; un cliente [Angular] modificado manualmente no podría eludir esta restricción;
  • líneas 27–31: [if (scheduleSlot.appointment === null) { this.book.emit(…); } else { this.cancel.emit(…); }] — si la franja horaria está disponible, se invita al usuario a reservarla; si ya está reservada, se invita al usuario a cancelar la cita existente. Este componente no realiza ninguna llamada HTTP por sí mismo: muestra los datos recibidos y notifica a su padre las intenciones del usuario.

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

Comentemos este código:

  • línea 1: [@if (schedule(); as currentSchedule) {] — @if y @for son la nueva sintaxis de control de flujo de [Angular]: reemplazan a *ngIf y *ngFor, respectivamente, y forman parte del propio lenguaje de plantillas (no requieren importar ningún módulo). as currentSchedule captura el valor no nulo en una variable de plantilla, lo que evita repetir `schedule()!` en todas partes después;
  • líneas 14–18: [@if (scheduleSlot.appointment === null) { ... } @else { ... }] — insignia verde de Bootstrap (“Free”/“Libre”) o gris (nombre del paciente), según el estado de la franja;
  • línea 21: [@if (canEdit()) {] — una novedad introducida por la autenticación: el botón “Book”/“Cancel” ni siquiera existe en el DOM para un rol USER (canEdit() es entonces false); no está simplemente atenuado ni deshabilitado, está completamente ausente;
  • línea 24: [{{ scheduleSlot.appointment === null ? (‘SCHEDULE.BOOK’ | translate) : (‘SCHEDULE.CANCEL_APPOINTMENT’ | translate) }}] — un pipe puede usarse dentro de cualquier expresión de plantilla, incluido un operador ternario, siempre que cada rama esté correctamente entre paréntesis.

6.10.7. src/app/features/booking-dialog/booking-dialog.component.ts

La ventana (modal) que permite seleccionar un paciente para reservar una franja disponible. Equivalente al ejemplo 9 del cliente AngularJS 1.x original.

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

Comentemos este código:

  • línea 12: [readonly open = input.required<boolean>();] — el componente está siempre presente en la plantilla del padre ([App]): esta entrada controla, mediante [@if] (véase la plantilla más abajo), si se muestra o no;
  • Líneas 26–33: [onConfirmClick(): void { … this.confirm.emit({ clientId }); this.selectedClientId.set(null); }] — transmite el ID del paciente seleccionado a [App], que luego llamará a AppointmentService.addAppointment(...); selectedClientId se restablece para la próxima vez que se abra la ventana;
  • líneas 35–38: [onCloseClick(): void { … this.close.emit(); }] — si el usuario cancela, el padre simplemente cierra la ventana sin hacer ninguna llamada al servidor.

6.10.8. src/app/features/booking-dialog/booking-dialog.component.html

Este componente utiliza ahora las clases reales de Bootstrap para un modal (.modal, .modal-dialog, .modal-content, .modal-backdrop…), pero su visibilidad sigue estando controlada por [Angular] ([@if] (open())) y no por el JavaScript de Bootstrap (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>
 }

Analicemos este código:

  • línea 2: [] — el fondo semitransparente que oscurece el resto de la página; está escrito directamente aquí, mientras que Bootstrap normalmente lo inserta por sí mismo mediante JavaScript cuando se muestra el modal;
  • línea 4: [<div class=“modal fade show d-block” …>] — d-block reemplaza el papel que normalmente cumple el JavaScript de Bootstrap (agregar `display:block` al abrirse); aquí es el [@if] de la línea 1 el que cumple directamente este papel;
  • líneas 6–10, 12–24, 26–31: [.modal-content / .modal-header / .modal-body / .modal-footer] — la estructura estándar de un modal de Bootstrap (encabezado con título + botón de cierre, cuerpo, pie con acciones);
  • línea 9: [[attr.aria-label]=“‘BOOKING_DIALOG.CLOSE_ARIA’ | translate”] — el botón de cierre estándar de Bootstrap (.btn-close), vinculado al mismo manejador de eventos que el botón “Cancel” del pie del modal (línea 27); su texto accesible (aria-label) se define mediante un enlace de atributo ([attr.xxx]) en lugar de una simple interpolación {{ }}, que es la única sintaxis posible cuando el valor de un atributo HTML no es texto estático.

¿Por qué no usar el JavaScript de Bootstrap? Porque Bootstrap y [Angular] gestionarían entonces, cada uno por su cuenta, la misma información (¿está abierto el modal?), una fuente clásica de errores sutiles en una aplicación Angular. Al dejar que open() (un signal y, por lo tanto, el estado [Angular]) controle por sí solo la visualización, se tiene una única fuente de verdad y se conserva exactamente la apariencia visual de un modal de Bootstrap. El documento original (2014) usaba un componente de la biblioteca angular-ui-bootstrap (un modal “llave en mano” de AngularJS 1.x), ya diseñado según este mismo principio: estado gestionado por [Angular], apariencia tomada de Bootstrap.

6.11. El componente raíz [App]: orquestador y guardián de la autenticación

Este componente cumple el papel que desempeñaba el “controlador principal” de la aplicación AngularJS 1.x original: mantiene el estado global de la aplicación y responde a los eventos de los componentes de features/ para llamar a [AppointmentService] en el momento adecuado. Desde la incorporación de la autenticación, ha asumido un segundo papel: el de “portero” de la capa de presentación, que decide si se muestra la pantalla de inicio de sesión o el resto de la aplicación.

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';
  // ... modelos, componentes (ver las importaciones detalladas del archivo)

 @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)),
      });
  }
 }

Comentemos este código:

  • línea 12: [imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],] — un componente standalone declara los componentes y pipes que usa en su plantilla; [LoginComponent] se agregó a esta lista por la autenticación, y [TranslatePipe] por la traducción;
  • línea 20: [protected readonly auth = inject(AuthService);] — expuesto a la plantilla (protected, no private) para la insignia de rol/nombre y el botón de cierre de sesión (véase [app.html]);
  • línea 21: [protected readonly language = inject(LanguageService);] — expuesto a la plantilla para los dos botones FR/EN de la barra de navegación, que siempre están visibles (incluso en la pantalla de inicio de sesión), a diferencia del resto de la interfaz;
  • Línea 33: [effect(() => { if (this.auth.isLoggedIn()) { this.loadInitialLists(); } });] — `effect()` vuelve a ejecutar su cuerpo cada vez que cambia un signal que supervisa; en este caso, isLoggedIn(). También se ejecuta una vez inmediatamente: si ya había una sesión almacenada en localStorage (recarga de la página), las listas se cargan desde el inicio, sin esperar un nuevo inicio de sesión;
  • línea 40: [private loadInitialLists(): void {] — cuando un usuario inicia sesión (inicio de sesión exitoso o sesión restaurada), las listas de médicos y clientes se cargan una sola vez; es el equivalente, esta vez del lado del cliente, de lo que hacía [ApplicationModelService] al iniciar el servidor (capítulo 3). Como ahora todos los endpoints del servidor están protegidos por [JwtAuthGuard], sería inútil (y provocaría errores 401) hacer esta llamada antes de iniciar sesión;
  • línea 51: [onLogout(): void {] — responde al botón “Log out”: borra la sesión y todo el estado de negocio mostrado (líneas 53–59); sin esto, un nuevo usuario que inicie sesión después vería brevemente el calendario del usuario anterior;
  • Líneas 41, 45, etc.: [.pipe(takeUntilDestroyed(this.destroyRef))] — una suscripción de RxJS (.subscribe(...)) permanece activa hasta que se cancela explícitamente; es un descuido frecuente y una fuente de fugas de memoria. Este operador cancela la suscripción automáticamente en cuanto se destruye el componente;
  • línea 69: [onBookingRequest(slot: SlotJson): void { this.slotBeingBooked.set(slot); }] — todavía no llama al servidor: simplemente abre la ventana de reserva. Es onConfirmBooking (línea 73), activado por el evento (confirm) de [BookingDialogComponent], el que realmente llama a addAppointment;
  • Líneas 81, 92: [this.loadSchedule();] — después de una reserva o cancelación exitosa, se vuelve a llamar a loadSchedule(): esto permite que el calendario mostrado refleje de inmediato el nuevo estado, sin que el usuario tenga que actualizar la página.

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>

Analicemos este código:

  • línea 2: [] — clases de Bootstrap para un encabezado de aplicación: un banner de color (bg-primary), texto claro (navbar-dark) y alineación horizontal automática de su contenido;
  • línea 3: [{{ ‘APP.TITLE’ | translate }}] — primer ejemplo del pipe `translate` ([@ngx-translate/core]): en lugar de un texto en inglés escrito directamente, una clave (APP.TITLE) que se resuelve en el diccionario del idioma actual (public/i18n/fr.json o en.json);
  • líneas 6–15: [<div class=“btn-group btn-group-sm” …> … FR … EN … ] — el selector de idioma, siempre visible (tanto antes como después de iniciar sesión, a diferencia de la insignia de rol): dos botones de Bootstrap agrupados (btn-group), uno de los cuales aparece resaltado (btn-light en lugar de btn-outline-light) según el idioma actual (language.currentLanguage()), y al hacer clic en cualquiera de ellos se llama a language.changeLanguage('fr' | 'en');
  • líneas 17–23: [@if (auth.isLoggedIn()) { ... badge + name + logout button ... }] — este bloque aparece solo después de iniciar sesión; auth.[role]() rellena una insignia de Bootstrap (text-bg-light badge), auth.[name]() muestra el nombre del usuario, y el texto del botón también pasa por | translate (clave APP.LOGOUT);
  • línea 28: [{{ ‘APP.SERVER_URL_LABEL’ | translate }}] — el mismo mecanismo que para el título, aplicado a la etiqueta del campo “Server URL”;
  • líneas 27–33: [Server URL] — permanece visible tanto antes como después del inicio de sesión (útil para apuntar a otro servidor, [NestJS], incluso antes de intentar iniciar sesión);
  • línea 39: [@if (!auth.isLoggedIn()) { <app-login /> } @else { ... }] — el núcleo del papel de “guardia” de [App]: mientras el usuario no haya iniciado sesión, no se muestra nada aparte de la pantalla de inicio de sesión: ni el selector de médico/día, ni el calendario, ni la ventana de reserva;
  • línea 46: [[canEdit]=“auth.isAdmin()”] — transmite a [ScheduleComponent] el control según si el usuario conectado tiene derecho a reservar/cancelar (rol ADMIN) o no (rol USER, solo lectura);
  • líneas 51–57: [<app-booking-dialog … />] — siempre presente en el DOM (igual que antes de la autenticación): su visibilidad está controlada por su entrada open.

Observe que el selector de idioma se coloca fuera del bloque [@if] (auth.isLoggedIn()): debe seguir siendo utilizable desde la pantalla de inicio de sesión, antes de que se emita cualquier token JWT; de hecho, la captura de pantalla siguiente (“Pantalla [Login]”) ilustra el cambio a francés en esta misma pantalla.

6.12. Guía paso a paso para usar la aplicación

Las siguientes capturas de pantalla se tomaron durante la preparación de este documento, con una copia de prueba del servidor poblada con datos de demostración (3 médicos, entre ellos la Sra. Marie PELISSIER; 4 clientes, entre ellos Brigitte BISTROU; y las dos cuentas admin/admin y user/user).

6.12.1. 1. Pantalla de inicio de sesión

Mientras el usuario no inicie sesión, solo se muestra la pantalla de inicio de sesión; el resto de la aplicación (selector de médico/día, calendario) aún no aparece en la página. Sin embargo, los dos botones “FR” y “EN” del encabezado ya se pueden usar en esta etapa; no se necesita ningún token para cambiar el idioma:

Image

Pantalla de inicio de sesión

Un intento con una contraseña incorrecta muestra un mensaje de error sin más detalles (para no revelar si el problema está en el nombre de usuario o en la contraseña):

Image

Error de inicio de sesión

Al hacer clic en “FR”, la pantalla se traduce al instante, incluido este mensaje de error si está visible en el momento en que se cambia el idioma; es una consecuencia directa de la decisión explicada antes en este capítulo (sección login.component.ts) de almacenar en error() una clave de traducción en lugar de un texto en inglés ya resuelto:

Image

Pantalla de inicio de sesión en francés

6.12.2. 2. Inicio de sesión como administrador (rol ADMIN)

Una vez iniciada la sesión con la cuenta admin/admin, el encabezado muestra el rol (insignia “ADMIN”) y el nombre del usuario, junto con un botón “Log out”. Aparece el selector de médico/día, igual que antes de la autenticación:

Image

Página de inicio, con sesión iniciada como ADMIN

La interfaz en francés sigue disponible una vez iniciada la sesión; entonces también traduce la insignia de rol, los nombres de las etiquetas y el botón "Log out":

Image

Página de inicio, tras iniciar sesión como ADMIN, en francés

Después de seleccionar un médico y hacer clic en “View schedule”, cada franja horaria disponible tiene un botón “Book” y cada franja reservada tiene un botón “Cancel”: el rol ADMIN tiene acceso completo, exactamente como antes de que se agregaran los roles:

Image

Calendario, vista ADMIN (botones Book/Cancel visibles)

Al hacer clic en “Book” se abre la ventana modal de Bootstrap, que le pide seleccionar un paciente:

Image

Ventana de reserva (modal de Bootstrap)

Después de seleccionar un paciente y hacer clic en “Confirm”, la ventana se cierra y el calendario se actualiza automáticamente: la franja reservada aparece ahora como ocupada, con el nombre del paciente seleccionado:

Image

Calendario después de la reserva

Al hacer clic en “Cancel” (cuando la franja está reservada), el calendario se actualiza de la misma manera: la franja vuelve a estar “Free”:

Image

Calendario después de la cancelación

6.12.3. 3. Inicio de sesión como usuario (rol USER, solo lectura)

Después de cerrar la sesión, al iniciar sesión con la cuenta user/user se muestra una insignia “USER” diferente:

Image

Pantalla de inicio, con sesión iniciada como USER

El calendario sigue siendo visible, pero no aparecen los botones “Book”/“Cancel”: la columna de acciones está vacía en cada franja horaria. Una solicitud directa al servidor (por ejemplo, con Postman y proporcionando el token del usuario) seguiría recibiendo una respuesta 403 Forbidden; ocultar los botones es solo una comodidad de visualización, y la restricción real la aplica [RolesGuard] del lado del servidor (capítulo 3):

Image

Calendario, vista USER (solo lectura, sin botones de acción)

6.13. Lo que queda fuera del alcance o aplazado

El modo “debug” (visualización de la plantilla sin procesar de la vista actual) del cliente AngularJS 1.x original es una funcionalidad deliberadamente omitida de este port; no aparecerá en una etapa posterior del curso (véase el capítulo 6, conclusión, para conocer las razones de esta decisión). En cambio, la configuración de un retraso de red artificial sí se aplaza a una etapa posterior.