Skip to content

10. Caso de estudio: el cliente Angular de la aplicación RdvMedecins

10.1. El problema

La aplicación [RdvMedecins] permite programar citas en un consultorio médico. El curso de [NestJS] la escribió como una aplicación HTML, en la que el servidor generaba las páginas. Aquí escribimos el cliente [Angular]: LAS MISMAS páginas, generadas en el navegador a partir de los datos JSON del servidor descrito en el capítulo «El servidor RdvMedecins: una caja negra».

El cliente debe ofrecer todo lo que ofrecía la aplicación HTML:

  • una página de inicio de sesión, protegida por un CAPTCHA, con la opción de crear una cuenta de paciente;
  • la agenda de un médico para un día determinado, con reserva de citas (ventana de selección de paciente) y cancelación;
  • para el administrador, la gestión de médicos y clientes (listar, agregar, editar, eliminar);
  • para el paciente, un panel personal (que muestra las próximas citas, que puede cancelar) y la gestión de la cuenta;
  • dos idiomas: francés e inglés;
  • URL únicas ([/schedule?doctorId=1&day=...]), que se pueden recargar, guardar como marcadores y recorrer con los botones Atrás/Adelante del navegador.

10.2. Instalación y ejecución

El servidor JSON debe estar instalado y en ejecución (véase el capítulo «El servidor RdvMedecins: una caja negra»). Para usar el cliente en un navegador, no necesita el modo de prueba del CAPTCHA: puede dejar el campo [CAPTCHA_TEST] vacío en el archivo [.env] del servidor.

En una ventana de consola abierta en la carpeta [rdvmedecins-angular]:

npm install
npm start

luego abra http://localhost:4200 en un navegador. Las cuentas de demostración aparecen en la página de inicio de sesión (contraseña = login).

Los ejemplos también usan el puerto 4200: primero, detenga el ejemplo que se esté ejecutando ([Ctrl-C]). También puede iniciar el cliente en otro puerto: [npm start -- --port 4300].

10.3. Uso de la aplicación

10.3.1. La página de inicio de sesión

Image

Contraseña incorrecta: aparece un mensaje en la parte inferior de la página y se muestra una nueva imagen (cada imagen solo puede usarse una vez):

Image

10.3.2. El calendario, visto por el administrador y los médicos

Al iniciar sesión como [admin], se accede al calendario:

Image

Seleccione un médico y un día, y luego haga clic en «Ver agenda». La URL pasa a ser [/schedule?doctorId=1&day=2026-10-05]:

Image

«Reservar» abre la ventana de reserva. La URL pasa a ser [/schedule?doctorId=1&day=2026-10-05&book=3]: al recargar la página (F5) se vuelve a abrir la misma ventana.

Image

La cita queda guardada:

Image

«Cancelar» solicita confirmación:

Image

Un médico llega directamente a SU PROPIA agenda del día:

Image

10.3.3. El portal del paciente

Un paciente ([martin]) llega a «Mi área»:

Image

En un calendario, ve «Reservado» junto a los horarios de las citas de otros pacientes:

Image

Reserva una cita para sí mismo sin seleccionar a un paciente:

Image

Su cita aparece bajo su nombre; el botón «Reservar» ya no está disponible (solo una cita próxima) y un mensaje explica el motivo:

Image

Su panel muestra lo siguiente:

Image

«Administrar mi cuenta»: cualquier cambio requiere la contraseña actual; los errores provienen del servidor:

Image

Si ingresa la dirección /doctors, que está reservada para el administrador:

Image

10.3.4. Gestión de médicos y clientes

Image

Un formulario completado incorrectamente:

Image

Un alta exitosa:

Image

Un homónimo:

Image

Se rechaza la solicitud de eliminar a un médico que tiene citas programadas:

Image

10.3.5. Creación de una cuenta

En la página de inicio de sesión, ingrese el CAPTCHA y luego haga clic en «Crear una cuenta de paciente». El formulario, completado incorrectamente, es entonces rechazado por el servidor:

Image

Una vez creada la cuenta, vuelva a la página de inicio de sesión; los campos de inicio de sesión aparecen rellenados:

Image

10.3.6. En francés

Los botones FR / EN traducen la página al instante, sin hacer ninguna solicitud al servidor; el título de la pestaña del navegador también se traduce:

Image

10.3.7. Sesión expirada, dirección desconocida

Si el token expira (o si se elimina la cookie), la siguiente solicitud recibe una respuesta 401; el cliente es redirigido a la página de inicio de sesión:

Image

Una dirección desconocida:

Image

10.4. Arquitectura del cliente

rdvmedecins-angular/
├── angular.json, package.json, tsconfig.json, proxy.conf.json
├── public/favicon.svg                the tab icon
└── src/
    ├── index.html                    THE page of the application
    ├── main.ts                       the startup
    ├── styles.css
    └── app/
        ├── app.config.ts             the configuration of the application
        ├── app.ts                    the layout shared by all the pages
        ├── app.routes.ts             the pages and their access rights
        ├── guards.ts                 the router guards
        ├── api/                      the API access layer
        ├── i18n/                     the languages
        ├── services/                 session, messages, confirmation, forms
        ├── pipes/                    the formatting
        ├── components/               the reusable components
        └── pages/                    the pages

Image

La siguiente tabla compara la aplicación HTML del curso de [NestJS] con este cliente:

Aplicación HTML (NestJS)
Cliente Angular
El servidor genera cada página ([res.render])
El servidor devuelve JSON; los componentes de [src/app/pages/] generan las páginas
[views/layout.hbs] y sus vistas parciales
[app.ts] y los componentes de [src/app/components/]
las rutas del controlador ([@Get('my-area')])
rutas del cliente ([app.routes.ts]); el servidor solo tiene rutas /api/...
[JwtAuthGuard] y [RolesGuard] redirigen a /login o a una página 403
guardias del enrutador; el servidor mantiene sus propias guardias, que devuelven 401 o 403
mensaje flash en una cookie
mensaje flash en un servicio, [MessagesService]
diccionarios leídos por el servidor, helper [{{t}}]
diccionarios en el cliente, [ngx-translate]; el servidor solo devuelve claves
idioma almacenado en una cookie
idioma almacenado en [localStorage]
formulario rechazado: el servidor vuelve a cargar la página
formulario rechazado: respuesta 400/409; el cliente muestra los errores debajo de los campos
Ventana de confirmación: un pequeño script, [public/js/app.js]
un servicio y un componente, [ConfirmDialog]
La aplicación funciona sin JavaScript
La aplicación ES JavaScript

El cliente [Vue.js] de la lección anterior tiene exactamente la misma estructura: los «stores» ([Pinia]) se han convertido en servicios, los «composables» se han convertido en servicios o funciones, y las vistas se han convertido en páginas.

A continuación se muestran todos los archivos del cliente. Están ampliamente comentados; estos comentarios forman parte del curso.

10.4.1. Configuración del proyecto

10.4.1.1. package.json

{
  "name": "rdvmedecins-angular",
  "version": "1.0.0",
  "description": "Angular client of the medical appointment booking application [RdvMedecins] - client of the JSON server [rdvmedecins-nestjs-json]",
  "private": true,
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
    "build": "ng build"
  },
  "dependencies": {
    "@angular/common": "^22.2.0",
    "@angular/compiler": "^22.2.0",
    "@angular/core": "^22.2.0",
    "@angular/forms": "^22.2.0",
    "@angular/platform-browser": "^22.2.0",
    "@angular/router": "^22.2.0",
    "@ngx-translate/core": "^18.0.0",
    "bootstrap": "^5.3.8",
    "rxjs": "~7.8.0",
    "tslib": "^2.8.0"
  },
  "devDependencies": {
    "@angular/build": "^22.2.0",
    "@angular/cli": "^22.2.0",
    "@angular/compiler-cli": "^22.2.0",
    "typescript": "~6.0.2"
  }
}
  • líneas 8–9: [npm start] inicia el servidor de desarrollo; [npm run build] compila la versión de producción;
  • líneas 11–22: las bibliotecas que usa la aplicación: las de [Angular], [ngx-translate], [Bootstrap] y [RxJS];
  • líneas 23–28: las herramientas de desarrollo: el compilador de [Angular], el comando [ng] y [TypeScript].

10.4.1.2. angular.json

{
  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
  "version": 1,
  "cli": {
    "packageManager": "npm",
    "analytics": false
  },
  "projects": {
    "rdvmedecins-angular": {
      "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": {
              "budgets": [
                { "type": "initial", "maximumWarning": "800kB", "maximumError": "1MB" },
                { "type": "anyComponentStyle", "maximumWarning": "4kB", "maximumError": "8kB" }
              ],
              "outputHashing": "all"
            },
            "development": {
              "optimization": false,
              "extractLicenses": false,
              "sourceMap": true
            }
          },
          "defaultConfiguration": "production"
        },
        "serve": {
          "builder": "@angular/build:dev-server",
          "options": {
            "proxyConfig": "proxy.conf.json"
          },
          "configurations": {
            "production": { "buildTarget": "rdvmedecins-angular:build:production" },
            "development": { "buildTarget": "rdvmedecins-angular:build:development" }
          },
          "defaultConfiguration": "development"
        }
      }
    }
  }
}

Esta vez, un solo proyecto, en la raíz de la carpeta (línea 11):

  • línea 18: el punto de entrada de la aplicación;
  • línea 20: el contenido de la carpeta [public] se copia tal cual en la aplicación compilada (el ícono);
  • línea 21: las hojas de estilo globales: la de [Bootstrap], seguida de la nuestra;
  • líneas 24–30: la configuración de producción. Los presupuestos (budgets) generan una advertencia (o un error) si la aplicación supera el tamaño especificado; [outputHashing] agrega una huella del contenido al nombre de cada archivo (véase el capítulo «Despliegue»);
  • línea 37: [ng build] compila la versión de producción por defecto;
  • línea 42: el proxy del servidor de desarrollo;
  • línea 48: [ng serve] usa la configuración de desarrollo (código sin optimizar, «source maps» para el depurador).

10.4.1.3. tsconfig.json, tsconfig.app.json, proxy.conf.json

{
  "compilerOptions": {
    "strict": true,
    "noImplicitOverride": true,
    "noPropertyAccessFromIndexSignature": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "skipLibCheck": true,
    "isolatedModules": true,
    "experimentalDecorators": true,
    "importHelpers": true,
    "resolveJsonModule": true,
    "target": "ES2022",
    "module": "preserve"
  },
  "angularCompilerOptions": {
    "strictInjectionParameters": true,
    "strictInputAccessModifiers": true,
    "strictTemplates": true
  },
  "files": [],
  "references": [
    {
      "path": "./tsconfig.app.json"
    }
  ]
}
  • Línea 3: el modo estricto de [TypeScript];
  • línea 14: la importación de los archivos JSON (los diccionarios);
  • línea 21: el compilador de [Angular] también verifica los tipos en las plantillas.
1
2
3
4
{
  "extends": "./tsconfig.json",
  "include": ["src/**/*.ts"]
}
1
2
3
4
5
6
{
  "/api": {
    "target": "http://localhost:8080",
    "secure": false
  }
}

El proxy del Ejemplo 22: las solicitudes /api/... se reenvían al servidor JSON.

10.4.2. Inicio de la aplicación

10.4.2.1. index.html

<!doctype html>
<!--
  index.html - LA página de la aplicación (Single Page Application).
  El servidor nunca envía otra: todo lo demás se construye en
  el navegador con Angular, en <app-root>. lang y title son
  actualizados por la aplicación según el idioma y la página mostrada.
-->
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>RdvMedecins</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" href="favicon.svg" type="image/svg+xml">
</head>
<body>
  <app-root></app-root>
  <!-- sin JavaScript, una aplicación Angular no puede mostrar nada: lo indicamos -->
  <noscript>RdvMedecins requires JavaScript. / RdvMedecins a besoin de JavaScript.</noscript>
</body>
</html>
  • Línea 17: el elemento donde [Angular] muestra el componente raíz;
  • línea 19: sin [JavaScript], una aplicación [Angular] no puede mostrar nada: lo indicamos.

10.4.2.2. src/main.ts

// =========================================================================
// main.ts - el arranque de la aplicación
// -------------------------------------------------------------------------
// El componente raíz (App) y la configuración de la aplicación
// (app.config.ts). Las hojas de estilo (Bootstrap, styles.css) se
// declaran en angular.json.
// =========================================================================

import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
import { appConfig } from './app/app.config';

bootstrapApplication(App, appConfig).catch((error) => console.error(error));

10.4.2.3. src/app/app.config.ts

// =========================================================================
// app.config.ts - la configuración de la aplicación
// -------------------------------------------------------------------------
//   - el enrutador, sus rutas (app.routes.ts), los parámetros de ruta
//     pasados a los inputs de las páginas, y el título de pestaña traducido;
//   - HttpClient, con el interceptor de los errores y del 401;
//   - ngx-translate (francés e inglés).
// =========================================================================

import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { provideRouter, TitleStrategy, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';
import { apiInterceptor } from './api/api.interceptor';
import { provideI18n } from './i18n/i18n';
import { TranslatedTitle } from './i18n/title.strategy';

export const appConfig: ApplicationConfig = {
  providers: [
    // los errores no controlados se reportan en la consola del navegador
    provideBrowserGlobalErrorListeners(),
    provideRouter(routes, withComponentInputBinding()),
    { provide: TitleStrategy, useClass: TranslatedTitle },
    provideHttpClient(withInterceptors([apiInterceptor])),
    provideI18n(),
  ],
};
  • línea 21: los errores no controlados (como una promesa rechazada que nadie está esperando) se informan en la consola del navegador;
  • línea 22: el enrutador, con los parámetros de ruta pasados a las entradas de la página (ejemplo 17);
  • Línea 23: [TitleStrategy] es el servicio del enrutador que establece el título de la pestaña después de cada navegación. Reemplazamos la de [Angular] por la nuestra ([i18n/title.strategy.ts]), que traduce el título. Esa es la esencia de la inyección de dependencias: se puede sustituir la clase del framework por una propia sin cambiar nada más;
  • línea 24: el cliente HTTP, con nuestro interceptor;
  • línea 25: [ngx-translate].

10.4.2.4. src/app/app.ts

// =========================================================================
// app.ts - el componente raíz: el LAYOUT común a todas las páginas
// -------------------------------------------------------------------------
// El equivalente de views/layout.hbs de la aplicación HTML:
//   - la barra de navegación;
//   - un mensaje de éxito ARRIBA;
//   - la página actual (<router-outlet>);
//   - el panel de errores ABAJO;
//   - el diálogo de confirmación, una vez para toda la aplicación.
// =========================================================================

import { Component } from '@angular/core';
import { RouterOutlet } from '@angular/router';
import { NavBar } from './components/nav-bar/nav-bar';
import { SuccessMessage } from './components/success-message';
import { ErrorPanel } from './components/error-panel';
import { ConfirmDialog } from './components/confirm-dialog/confirm-dialog';

@Component({
  selector: 'app-root',
  imports: [RouterOutlet, NavBar, SuccessMessage, ErrorPanel, ConfirmDialog],
  template: `
    <div class="container py-4">
      <app-nav-bar />
      <app-success-message />
      <router-outlet />
      <app-error-panel />
    </div>
    <app-confirm-dialog />
  `,
})
export class App {}
  • Líneas 22–30: la plantilla común a todas las páginas: la barra de navegación, el mensaje de éxito, la página actual, el área de errores y la ventana de confirmación (Ejemplo 16).

10.4.2.5. src/styles.css

/* =========================================================================
   styles.css - algunos ajustes sobre Bootstrap
   (tomados de public/css/styles.css de la aplicación HTML)
   ========================================================================= */

body {
  background-color: #f5f7fa;
}

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

/* -------------------------------------------------------------------------
   .error-panel: los mensajes de error, al pie de la página, sobre un fondo
   rosa claro (véase components/error-panel.ts).
   position: sticky + bottom: si la página es más alta que la ventana, el
   panel permanece pegado al fondo de la ventana en lugar de desaparecer debajo
   del borde inferior, sin cubrir nunca el contenido cuando la página
   es corta. z-index: por encima del fondo atenuado de los diálogos modales.
   pointer-events: none: el panel no contiene nada en lo que se pueda hacer clic; si
   se superpone a un botón, el clic lo atraviesa.
   ------------------------------------------------------------------------- */
.error-panel {
  position: sticky;
  bottom: 1rem;
  z-index: 1060;
  pointer-events: none;
  margin-top: 1.5rem;
  padding: 0.75rem 1rem;
  background-color: #fdecef; /* rosa claro */
  border: 1px solid #f5c2c7;
  border-radius: 0.375rem;
  color: #842029;
}

/* las dos grandes opciones de la página "Mi área" del paciente */
.option-card {
  transition: border-color 0.15s, box-shadow 0.15s;
}

.option-card:hover {
  border-color: #0d6efd;
  box-shadow: 0 0.25rem 0.75rem rgba(13, 110, 253, 0.15);
}

/* la imagen del captcha (SVG de 150 x 50 píxeles), insertada por [innerHTML]:
   solo un estilo GLOBAL, como este, puede alcanzarla */
.captcha-image svg {
  display: block;
  border: 1px solid #dee2e6;
  border-radius: 0.375rem;
}
  • Líneas 24–35: el área de errores en la parte inferior de la página;
  • líneas 49–53: la imagen del CAPTCHA. Como en el Ejemplo 24, un [<svg>] insertado mediante [[innerHTML]] solo recibe estilo de un estilo global.

10.4.3. La capa de acceso a la API

10.4.3.1. src/app/api/types.ts

// =========================================================================
// api/types.ts - los objetos JSON intercambiados con el servidor
// -------------------------------------------------------------------------
// La traducción, a interfaces de TypeScript, de la API descrita en el
// capítulo "El servidor, una caja negra". El compilador verifica así que el cliente
// solo use campos que realmente existen.
// =========================================================================

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

// POST /api/auth/login, GET /api/auth/me, PUT /api/my-account
export interface User {
  login: string;
  name: string; // nombre mostrado: "Marie PELISSIER"
  role: Role;
}

// GET /api/captcha
export interface Captcha {
  id: string;
  svg: string;
}

// un título, un nombre, un apellido
export interface Identity {
  title: string;
  firstName: string;
  lastName: string;
}

// un médico o un cliente: GET /api/doctors, GET /api/clients/:id...
export interface Person extends Identity {
  id: number;
  version: number; // bloqueo optimista: debe reenviarse con una actualización
  login?: string; // solo para el ADMIN
}

// lo que se envía para crear / actualizar una persona (ADMIN)
export interface PersonData extends Identity {
  login: string; // '' = valor por defecto (creación) o sin cambios (actualización)
  password: string; // igual
  version?: number;
}

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

// una fila de la agenda, con los DERECHOS del usuario que ha iniciado sesión
export interface ScheduleSlot extends Slot {
  free: boolean;
  patient: Identity | null; // null: libre, o tomada por otro paciente
  mine: boolean; // la cita del paciente que ha iniciado sesión
  bookable: boolean;
  appointmentId: number | null; // establecido si el usuario puede cancelar
}

// GET /api/schedule?doctorId=...&day=...
export interface Schedule {
  doctor: Person;
  day: string; // "yyyy-MM-dd"
  slots: ScheduleSlot[];
  info: string | null; // clave de traducción (paciente que ya tiene una cita)
}

// GET /api/my-area
export interface MyArea {
  patient: Identity;
  appointments: { id: number; day: string; slot: Slot; doctor: Person }[];
}

// GET /api/my-account
export interface MyAccount extends Identity {
  login: string;
  version: number;
}

// PUT /api/my-account
export interface MyAccountUpdate extends Identity {
  login: string;
  password: string; // '' = sin cambios
  confirmation: string;
  currentPassword: string;
  version: number;
}

// POST /api/register
export interface Registration extends Identity {
  login: string;
  password: string;
  confirmation: string;
}

La traducción a interfaces de [TypeScript] de la API descrita en el capítulo «El servidor RdvMedecins, una caja negra». La palabra clave [extends] evita repetir campos comunes: una [Person] es una [Identity] (título, nombre, apellido) con un identificador y una versión.

10.4.3.2. src/app/api/api-error.ts

// =========================================================================
// api/api-error.ts - UNA clase para todos los errores de la API
// -------------------------------------------------------------------------
// Tomado de common/api-error.ts de los ejemplos. Cualquier error de una petición
// (respuesta 4xx / 5xx del servidor, servidor inaccesible, respuesta de un proxy)
// se convierte en un ApiError, que lleva la CLAVE de traducción del mensaje, sus
// parámetros y el error de cada campo de un formulario rechazado.
// =========================================================================

import { HttpErrorResponse } from '@angular/common/http';

export class ApiError extends Error {
  constructor(
    public readonly statusCode: number, // 0: el servidor no respondió
    public readonly key: string, // clave de traducción: 'ERRORS.LOGIN_TAKEN'
    public readonly params: Record<string, string> = {},
    public readonly fields: Record<string, string> = {}, // error de cada campo
  ) {
    super(key);
    this.name = 'ApiError';
  }
}

export function toApiError(e: unknown): ApiError {
  if (e instanceof ApiError) {
    return e;
  }
  if (!(e instanceof HttpErrorResponse)) {
    return new ApiError(0, 'ERRORS.SERVER_ERROR');
  }
  const body = (typeof e.error === 'object' && e.error !== null ? e.error : {}) as {
    key?: string;
    params?: Record<string, string>;
    fields?: Record<string, string>;
  };
  return new ApiError(
    e.status,
    // sin key: no fue nuestro servidor el que respondió, sino la red
    // o un proxy (ng serve: 500 sin cuerpo; nginx: 502, 504...)
    body.key ?? (e.status === 0 || e.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR'),
    body.params,
    body.fields,
  );
}

El archivo [common/api-error.ts] del Ejemplo 24.

10.4.3.3. src/app/api/api.interceptor.ts

// =========================================================================
// api/api.interceptor.ts - el interceptor de TODAS las peticiones a la API
// -------------------------------------------------------------------------
// Tomado de common/errors.interceptor.ts de los ejemplos, con una novedad:
// el manejo centralizado de la respuesta 401.
//
// Un 401 puede llegar en cualquier momento: el token ha expirado (2 horas), la
// cuenta ha sido eliminada, el servidor se ha reiniciado con otra clave
// secreta... En lugar de manejar este caso en cada componente, lo manejamos
// AQUÍ, una sola vez: olvidamos al usuario, preparamos el mensaje
// "sesión expirada" y volvemos a la página de inicio de sesión.
//
// Algunas peticiones manejan su 401 por sí mismas (el login, GET
// /api/auth/me...): lo indican con un TOKEN DE CONTEXTO
// (HttpContextToken), una información adjunta a la petición, que
// el interceptor lee (ver api/rdvmedecins.api.ts).
// =========================================================================

import { inject } from '@angular/core';
import { HttpContextToken, HttpInterceptorFn } from '@angular/common/http';
import { Router } from '@angular/router';
import { catchError, throwError } from 'rxjs';
import { toApiError } from './api-error';
import { SessionService } from '../services/session.service';
import { MessagesService } from '../services/messages.service';

// true: la petición maneja por sí misma un posible 401 (false por defecto)
export const IGNORE_401 = new HttpContextToken<boolean>(() => false);

export const apiInterceptor: HttpInterceptorFn = (req, next) => {
  // inject: los servicios que se necesitarán (en el contexto de inyección
  // del interceptor, ANTES de enviar la petición)
  const session = inject(SessionService);
  const messages = inject(MessagesService);
  const router = inject(Router);

  return next(req).pipe(
    catchError((e: unknown) => {
      const error = toApiError(e);
      if (error.statusCode === 401 && !req.context.get(IGNORE_401)) {
        session.forget();
        messages.flash('error', 'ERRORS.SESSION_EXPIRED');
        router.navigate(['/login']);
      }
      return throwError(() => error);
    }),
  );
};

El interceptor del Ejemplo 24, con una novedad: el tratamiento centralizado de la respuesta 401. Un 401 puede producirse en cualquier momento: el token ha expirado, la cuenta ha sido eliminada... En lugar de tratar este caso en cada página, lo tratamos aquí, una sola vez.

  • Línea 28: un token de contexto ([HttpContextToken]): información adjunta a una solicitud que el interceptor puede leer. Por defecto, vale [false];
  • Líneas 33–35: el interceptor inyecta los servicios que necesitará. [inject] debe llamarse al principio de la función: más adelante, en [catchError], el contexto de inyección ya no existe;
  • línea 39: cualquier error se convierte en un [ApiError];
  • líneas 40–44: una respuesta 401 para una solicitud que no la maneja por sí misma: se olvida al usuario, se prepara el mensaje «sesión expirada» (se mostrará en la página siguiente) y se redirige al usuario a la página de inicio de sesión;
  • línea 45: el error se transmite, en todos los casos, al código que realizó la solicitud.

10.4.3.4. src/app/api/rdvmedecins.api.ts

// =========================================================================
// api/rdvmedecins.api.ts - un método por ruta de la API
// -------------------------------------------------------------------------
// La "capa de acceso a datos" del cliente: los componentes llaman a estos
// métodos tipados, sin saber nada de las URL, de HttpClient ni de JSON. Si
// la API cambia, solo cambia este archivo.
// Cada método devuelve una PROMESA (firstValueFrom): los componentes
// encadenan las peticiones con async / await. Si falla, la promesa
// es rechazada con un ApiError (ver api.interceptor.ts).
// =========================================================================

import { inject, Injectable } from '@angular/core';
import { HttpClient, HttpContext, HttpParams } from '@angular/common/http';
import { firstValueFrom } from 'rxjs';
import { IGNORE_401 } from './api.interceptor';
import {
  Schedule,
  Captcha,
  PersonData,
  Registration,
  MyAccountUpdate,
  MyAccount,
  MyArea,
  Person,
  User,
} from './types';

// /api/doctors o /api/clients: ambos se manejan igual
export type PersonType = 'doctors' | 'clients';

type Empty = Record<string, never>;
type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';

@Injectable({ providedIn: 'root' })
export class RdvMedecinsApi {
  private readonly http = inject(HttpClient);

  // la petición en sí; isPublic: true para las rutas que manejan
  // el 401 por sí mismas (rutas públicas, GET /api/auth/me)
  private request<T>(method: Method, url: string, body?: unknown, isPublic = false, params?: HttpParams): Promise<T> {
    return firstValueFrom(
      this.http.request<T>(method, `/api${url}`, {
        body,
        params,
        context: new HttpContext().set(IGNORE_401, isPublic),
      }),
    );
  }

  // login (rutas públicas)
  captcha(): Promise<Captcha> {
    return this.request<Captcha>('GET', '/captcha', undefined, true);
  }
  me(): Promise<User> {
    return this.request<User>('GET', '/auth/me', undefined, true);
  }
  logIn(login: string, password: string, captchaId: string, captcha: string): Promise<User> {
    return this.request<User>('POST', '/auth/login', { login, password, captchaId, captcha }, true);
  }
  logOut(): Promise<Empty> {
    return this.request<Empty>('POST', '/auth/logout', {}, true);
  }

  // creación de cuenta (pública)
  registrationAccess(captchaId: string, captcha: string): Promise<Empty> {
    return this.request<Empty>('POST', '/register/access', { captchaId, captcha }, true);
  }
  registrationAccessStatus(): Promise<{ valid: boolean }> {
    return this.request<{ valid: boolean }>('GET', '/register/access', undefined, true);
  }
  register(data: Registration): Promise<{ login: string }> {
    return this.request<{ login: string }>('POST', '/register', data, true);
  }

  // agenda y citas
  // doctorId null: para un médico que ha iniciado sesión, SU propia agenda
  schedule(doctorId: number | null, day: string): Promise<Schedule> {
    let params = new HttpParams().set('day', day);
    if (doctorId !== null) {
      params = params.set('doctorId', doctorId);
    }
    return this.request<Schedule>('GET', '/schedule', undefined, false, params);
  }
  book(day: string, slotId: number, clientId: number | null): Promise<{ id: number }> {
    return this.request<{ id: number }>('POST', '/appointments', { day, slotId, clientId: clientId ?? undefined });
  }
  cancelAppointment(appointmentId: number): Promise<Empty> {
    return this.request<Empty>('DELETE', `/appointments/${appointmentId}`);
  }

  // médicos y clientes
  list(type: PersonType): Promise<Person[]> {
    return this.request<Person[]>('GET', `/${type}`);
  }
  read(type: PersonType, id: number): Promise<Person> {
    return this.request<Person>('GET', `/${type}/${id}`);
  }
  add(type: PersonType, data: PersonData): Promise<Person> {
    return this.request<Person>('POST', `/${type}`, data);
  }
  edit(type: PersonType, id: number, data: PersonData): Promise<Person> {
    return this.request<Person>('PUT', `/${type}/${id}`, data);
  }
  remove(type: PersonType, id: number): Promise<Empty> {
    return this.request<Empty>('DELETE', `/${type}/${id}`);
  }

  // el área del paciente
  myArea(): Promise<MyArea> {
    return this.request<MyArea>('GET', '/my-area');
  }
  myAccount(): Promise<MyAccount> {
    return this.request<MyAccount>('GET', '/my-account');
  }
  editMyAccount(data: MyAccountUpdate): Promise<User> {
    return this.request<User>('PUT', '/my-account', data);
  }
  deleteMyAccount(currentPassword: string): Promise<Empty> {
    return this.request<Empty>('DELETE', '/my-account', { currentPassword });
  }
}

La capa de acceso a la API: un método por ruta.

  • Líneas 40–48: un único método maneja todas las solicitudes. [http.request] acepta el método HTTP como parámetro; [firstValueFrom] lo convierte en una promesa;
  • línea 45: la solicitud lleva el token de contexto [IGNORE_401]: true para las rutas que manejan el 401 por sí mismas. ¡Una contraseña incorrecta devuelve un 401: no es una sesión expirada! Del mismo modo, [GET /api/auth/me] devuelve un 401 cuando nadie ha iniciado sesión, lo cual es normal;
  • líneas 77–83: [HttpParams] genera los parámetros de la URL (?day=...&doctorId=...). Un objeto [HttpParams] no cambia: [set] devuelve un objeto nuevo;
  • línea 85: [clientId ?? undefined]: si falta un [clientId] , no se envía en absoluto;
  • Líneas 92–106: los médicos y los clientes se tratan de la misma manera: el tipo (['doctors'] o ['clients']) forma parte de la dirección;
  • línea 119: un DELETE con un cuerpo que contiene la contraseña actual, necesaria para eliminar la cuenta.

10.4.4. Idiomas

10.4.4.1. src/app/i18n/i18n.ts

// =========================================================================
// i18n/i18n.ts - francés e inglés (ngx-translate, ver ejemplo 21)
// -------------------------------------------------------------------------
// Los diccionarios fr.json y en.json son los del curso de NestJS
// (i18n/*.json), completados con algunas claves específicas del cliente
// (ERRORS.SERVER_UNREACHABLE...). El servidor JSON solo devuelve CLAVES
// ('ERRORS.LOGIN_TAKEN'): son las mismas que las de los diccionarios.
//
// El idioma elegido se guarda en localStorage (una preferencia, no un dato
// sensible); si no, se usa el idioma del navegador.
// =========================================================================

import { Provider } from '@angular/core';
import { provideTranslateLoader, provideTranslateService, TranslateLoader, TranslationObject } from '@ngx-translate/core';
import { Observable, of } from 'rxjs';
import fr from './fr.json';
import en from './en.json';

export type Language = 'fr' | 'en';
export const LANGUAGES: Language[] = ['fr', 'en'];
export const STORAGE_KEY = 'rdvmedecins.language';

// los diccionarios forman parte del código de la aplicación: ninguna petición
class DictionariesLoader implements TranslateLoader {
  getTranslation(language: string): Observable<TranslationObject> {
    return of(language === 'en' ? en : fr);
  }
}

export function initialLanguage(): Language {
  try {
    const stored = localStorage.getItem(STORAGE_KEY);
    if (stored === 'fr' || stored === 'en') {
      return stored;
    }
  } catch {
    // localStorage no disponible (navegación privada estricta...): no importa
  }
  return navigator.language.toLowerCase().startsWith('fr') ? 'fr' : 'en';
}

export function provideI18n(): Provider[] {
  return provideTranslateService({
    loader: provideTranslateLoader(DictionariesLoader),
    fallbackLang: 'en',
    lang: initialLanguage(),
  });
}

La configuración de [ngx-translate] del Ejemplo 21:

  • Líneas 30–40: el idioma de origen es el que el usuario seleccionó por última vez; de lo contrario, francés si el idioma del navegador es el francés, e inglés en cualquier otro caso. El acceso a [localStorage] puede fallar (en ciertos modos de navegación privada), por lo que se omite en ese caso.

10.4.4.2. src/app/i18n/language.service.ts

// =========================================================================
// i18n/language.service.ts - el idioma actual, y la forma de cambiarlo
// =========================================================================

import { inject, Injectable } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { STORAGE_KEY, Language } from './i18n';

@Injectable({ providedIn: 'root' })
export class LanguageService {
  private readonly translate = inject(TranslateService);
  // un signal: 'fr' o 'en'
  readonly language = this.translate.currentLang;

  constructor() {
    document.documentElement.lang = this.translate.getCurrentLang() ?? 'en';
  }

  // cambiar el idioma: toda la aplicación se traduce de nuevo de una vez
  change(language: Language): void {
    this.translate.use(language);
    document.documentElement.lang = language;
    try {
      localStorage.setItem(STORAGE_KEY, language);
    } catch {
      // sin importancia
    }
  }
}
  • línea 13: el idioma actual, una señal;
  • líneas 20–28: cambio de idioma: se vuelve a traducir la página (línea 21), se actualiza el atributo [lang] de la página (línea 22) y se guarda la selección (línea 24).

10.4.4.3. src/app/i18n/title.strategy.ts

// =========================================================================
// i18n/title.strategy.ts - el título de la pestaña, traducido
// -------------------------------------------------------------------------
// Cada ruta declara un título (title: 'SCHEDULE.PAGE_TITLE', ver
// app.routes.ts). Por defecto, Angular lo escribe TAL CUAL en la pestaña. Una
// TitleStrategy reemplaza este comportamiento: updateTitle() se llama después de
// cada navegación; buildTitle() da el título de la ruta mostrada
// (aquí, una clave), que traducimos. Y cuando cambia el idioma, el
// último título se traduce de nuevo.
// La clase se declara en app.config.ts:
//     { provide: TitleStrategy, useClass: TranslatedTitle }
// =========================================================================

import { inject, Injectable } from '@angular/core';
import { Title } from '@angular/platform-browser';
import { RouterStateSnapshot, TitleStrategy } from '@angular/router';
import { TranslateService } from '@ngx-translate/core';

@Injectable({ providedIn: 'root' })
export class TranslatedTitle extends TitleStrategy {
  private readonly title = inject(Title);
  private readonly translate = inject(TranslateService);
  private key: string | undefined;

  constructor() {
    super();
    this.translate.onLangChange.subscribe(() => this.apply());
  }

  override updateTitle(snapshot: RouterStateSnapshot): void {
    this.key = this.buildTitle(snapshot);
    this.apply();
  }

  private apply(): void {
    const application = this.translate.instant('APP.TITLE');
    this.title.setTitle(this.key ? `${this.translate.instant(this.key)} - ${application}` : application);
  }
}

Cada ruta declara un título, que en este caso es una clave de traducción ('SCHEDULE.PAGE_TITLE'). Por defecto, [Angular] la escribiría tal cual en la pestaña. Esta clase reemplaza el servicio [TitleStrategy] del enrutador (app.config.ts, línea 23):

  • línea 20: hereda la clase [TitleStrategy] de [Angular];
  • líneas 30–33: [updateTitle] es llamado por el enrutador después de cada navegación; [buildTitle], que se hereda, proporciona el título declarado por la ruta mostrada;
  • líneas 35–38: el título traducido, seguido del nombre de la aplicación: «Schedule - RdvMedecins»;
  • línea 27: cuando cambia el idioma, se vuelve a traducir el último título.

10.4.4.4. Los diccionarios

Los diccionarios [fr.json] y [en.json] son los de la aplicación HTML del curso de [NestJS], complementados con algunas claves propias del cliente ([ERRORS.SERVER_UNREACHABLE]...). Solo cambia la sintaxis de sus parámetros: [{{min}}] para [ngx-translate]. El servidor JSON devuelve las mismas claves.

{
  "APP": {
    "TITLE": "RdvMedecins",
    "LOGOUT": "Se déconnecter",
    "MENU_SCHEDULE": "Agenda",
    "MENU_DOCTORS": "Médecins",
    "MENU_PATIENTS": "Clients",
    "MENU_MY_AREA": "Mon espace",
    "LOADING": "Chargement...",
    "LANGUAGE": "Langue"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS": "Comptes de démonstration (mot de passe = login) :",
    "DEMO_ADMIN": "rôle ADMIN : rendez-vous + gestion des médecins et des clients",
    "DEMO_DOCTOR": "rôle DOCTOR : prise et annulation de rendez-vous",
    "DEMO_USER": "rôle USER (patients) : réservation pour eux-mêmes, gestion de leur compte",
    "CREATE_ACCOUNT": "Créer un compte client",
    "CREATE_ACCOUNT_HELP": "Pour créer un compte, recopiez d'abord les caractères de l'image."
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Médecin",
    "CHOOSE_DOCTOR": "-- choisir un médecin --",
    "DAY_LABEL": "Jour",
    "VIEW_SCHEDULE": "Voir l'agenda"
  },
  "SCHEDULE": {
    "PAGE_TITLE": "Agenda",
    "TITLE_PREFIX": "Agenda du",
    "COLUMN_SLOT": "Créneau",
    "COLUMN_STATUS": "Statut",
    "FREE": "Libre",
    "BOOK": "Réserver",
    "CANCEL_APPOINTMENT": "Annuler",
    "CANCEL_CONFIRM": "Annuler ce rendez-vous ?",
    "EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda ».",
    "NO_SLOTS": "Ce médecin n'a aucun créneau horaire.",
    "BOOKED": "Rendez-vous enregistré.",
    "CANCELLED": "Rendez-vous annulé.",
    "BOOKED_BY_OTHER": "Réservé",
    "ALREADY_BOOKED_INFO": "Vous avez déjà un rendez-vous à venir : annulez-le pour en prendre un autre."
  },
  "BOOKING_DIALOG": {
    "TITLE": "Réserver ce créneau",
    "CLOSE_ARIA": "Fermer",
    "SLOT": "Créneau de {{time}}",
    "PATIENT_LABEL": "Patient",
    "CHOOSE_PATIENT": "-- choisir un patient --",
    "CANCEL": "Annuler",
    "CONFIRM": "Confirmer"
  },
  "PERSONS": {
    "COLUMN_TITLE": "Titre",
    "COLUMN_FIRSTNAME": "Prénom",
    "COLUMN_LASTNAME": "Nom",
    "COLUMN_LOGIN": "Login",
    "EDIT": "Modifier",
    "DELETE": "Supprimer",
    "SAVE": "Enregistrer",
    "BACK": "Retour à la liste",
    "TITLE_LABEL": "Titre",
    "FIRSTNAME_LABEL": "Prénom",
    "LASTNAME_LABEL": "Nom",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "LOGIN_HELP_CREATE": "Facultatif : par défaut, le nom en minuscules.",
    "LOGIN_HELP_EDIT": "Laisser vide pour ne pas le changer.",
    "PASSWORD_HELP_CREATE": "Facultatif : par défaut, identique au login.",
    "PASSWORD_HELP_EDIT": "Laisser vide pour ne pas le changer.",
    "ACCOUNT_SECTION": "Compte utilisateur"
  },
  "DOCTORS": {
    "TITLE": "Médecins",
    "ADD": "Ajouter un médecin",
    "EDIT": "Modifier un médecin",
    "EMPTY": "Aucun médecin.",
    "DELETE_CONFIRM": "Supprimer ce médecin, ses créneaux horaires et son compte utilisateur ?",
    "ADDED": "Le médecin {{name}} a été ajouté (login : {{login}}).",
    "UPDATED": "Le médecin {{name}} a été modifié.",
    "DELETED": "Le médecin {{name}} a été supprimé."
  },
  "CLIENTS": {
    "TITLE": "Clients",
    "ADD": "Ajouter un client",
    "EDIT": "Modifier un client",
    "EMPTY": "Aucun client.",
    "DELETE_CONFIRM": "Supprimer ce client, son compte utilisateur et tous ses rendez-vous ?",
    "ADDED": "Le client {{name}} a été ajouté (login : {{login}}).",
    "UPDATED": "Le client {{name}} a été modifié.",
    "DELETED": "Le client {{name}} a été supprimé."
  },
  "ERROR_PAGE": {
    "TITLE": "Erreur",
    "BACK": "Retour à l'accueil"
  },
  "ERRORS": {
    "LOGIN_TAKEN": "Ce login est déjà utilisé par un autre compte.",
    "DOCTOR_ALREADY_EXISTS": "Un médecin portant ce prénom et ce nom existe déjà.",
    "PATIENT_ALREADY_EXISTS": "Un client portant ce prénom et ce nom existe déjà.",
    "DOCTOR_HAS_APPOINTMENTS": "Ce médecin a des rendez-vous : annulez-les avant de le supprimer.",
    "SLOT_ALREADY_BOOKED": "Ce créneau vient d'être réservé par quelqu'un d'autre.",
    "CONCURRENT_UPDATE": "Cette fiche a été modifiée entre-temps par un autre utilisateur. Revenez à la liste et rouvrez-la avant de recommencer.",
    "DOCTOR_NOT_FOUND": "Ce médecin n'existe pas (ou plus).",
    "PATIENT_NOT_FOUND": "Ce client n'existe pas (ou plus).",
    "SLOT_NOT_FOUND": "Ce créneau n'existe pas (ou plus).",
    "APPOINTMENT_NOT_FOUND": "Ce rendez-vous n'existe pas (ou plus).",
    "INVALID_DATE": "La date demandée n'est pas valide.",
    "CHOOSE_PATIENT": "Choisissez un patient.",
    "INVALID_FORM": "Le formulaire contient des erreurs.",
    "INVALID_TITLE": "Choisissez un titre dans la liste.",
    "FIRSTNAME_REQUIRED": "Le prénom est obligatoire.",
    "FIRSTNAME_TOO_LONG": "Le prénom ne doit pas dépasser 20 caractères.",
    "LASTNAME_REQUIRED": "Le nom est obligatoire.",
    "LASTNAME_TOO_LONG": "Le nom ne doit pas dépasser 20 caractères.",
    "INVALID_LOGIN": "30 caractères au plus : lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
    "PASSWORD_TOO_LONG": "Le mot de passe ne doit pas dépasser 72 caractères.",
    "SESSION_EXPIRED": "Votre session a expiré : reconnectez-vous.",
    "BAD_REQUEST": "La requête est invalide.",
    "FORBIDDEN": "Votre rôle ne vous permet pas d'accéder à cette page.",
    "NOT_FOUND": "Cette page n'existe pas.",
    "SERVER_ERROR": "Une erreur inattendue s'est produite. Réessayez plus tard.",
    "TOO_MANY_ATTEMPTS": "Trop de tentatives infructueuses. Réessayez dans {{minutes}} minute(s).",
    "WRONG_CAPTCHA": "Les caractères recopiés ne correspondent pas à l'image. Une nouvelle image vous est proposée.",
    "TOO_MANY_ACCOUNTS": "Trop de comptes ont été créés depuis votre connexion. Réessayez dans {{minutes}} minute(s).",
    "LOGIN_REQUIRED": "Le login est obligatoire.",
    "PASSWORD_REQUIRED": "Le mot de passe est obligatoire.",
    "PASSWORD_TOO_SHORT": "Le mot de passe doit comporter au moins {{min}} caractères.",
    "CONFIRMATION_REQUIRED": "Confirmez le mot de passe.",
    "PASSWORDS_DIFFER": "La confirmation ne correspond pas au mot de passe.",
    "CURRENT_PASSWORD_REQUIRED": "Saisissez votre mot de passe actuel.",
    "WRONG_CURRENT_PASSWORD": "Mot de passe actuel incorrect.",
    "PAST_DATE": "On ne peut pas prendre de rendez-vous à une date passée.",
    "PATIENT_HAS_UPCOMING_APPOINTMENT": "Ce patient a déjà un rendez-vous à venir : il faut l'annuler avant d'en prendre un autre.",
    "CAPTCHA_BEFORE_ACCOUNT": "Pour créer un compte, recopiez d'abord correctement les caractères de l'image, puis cliquez sur « Créer un compte client ».",
    "AUTH_REQUIRED": "Connectez-vous pour accéder à cette page.",
    "JSON_REQUIRED": "Requête refusée : le serveur attend du JSON.",
    "SERVER_UNREACHABLE": "Le serveur ne répond pas. Réessayez plus tard."
  },
  "CAPTCHA": {
    "LABEL": "Recopiez les caractères de l'image",
    "IMAGE_ALT": "Image de vérification anti-robots",
    "NEW_IMAGE": "Autre image",
    "HELP": "Majuscules ou minuscules, peu importe."
  },
  "REGISTRATION": {
    "TITLE": "Créer un compte client",
    "INTRO": "Ce compte vous permettra de prendre vous-même vos rendez-vous.",
    "LOGIN_HELP": "Lettres minuscules non accentuées, chiffres, point, tiret, souligné.",
    "PASSWORD_HELP": "Au moins {{min}} caractères.",
    "SUBMIT": "Créer mon compte",
    "BACK_TO_LOGIN": "Retour à la connexion",
    "DONE": "Votre compte a été créé. Vous pouvez vous connecter avec le login {{login}}."
  },
  "ACCOUNT": {
    "CONFIRMATION_LABEL": "Confirmation du mot de passe"
  },
  "AREA": {
    "TITLE": "Mon espace",
    "HELLO": "Bonjour {{name}}",
    "MANAGE_ACCOUNT": "Gérer mon compte",
    "MANAGE_ACCOUNT_HELP": "Modifier mes informations, mon mot de passe, ou supprimer mon compte.",
    "VIEW_SCHEDULE": "Voir un agenda",
    "VIEW_SCHEDULE_HELP": "Consulter l'agenda d'un médecin et réserver un créneau.",
    "MY_APPOINTMENT": "Mon rendez-vous",
    "SEE_IN_SCHEDULE": "voir dans l'agenda",
    "CANCEL_APPOINTMENT": "Annuler ce rendez-vous",
    "NO_APPOINTMENT": "Vous n'avez aucun rendez-vous à venir."
  },
  "MY_ACCOUNT": {
    "TITLE": "Gérer mon compte",
    "NEW_PASSWORD_LABEL": "Nouveau mot de passe",
    "CURRENT_PASSWORD_LABEL": "Mot de passe actuel",
    "CURRENT_PASSWORD_HELP": "Obligatoire pour enregistrer une modification.",
    "BACK": "Retour à mon espace",
    "DELETE_TITLE": "Supprimer mon compte",
    "DELETE_HELP": "Votre compte sera définitivement supprimé, ainsi que tous vos rendez-vous.",
    "DELETE_CONFIRM": "Supprimer définitivement votre compte ? Votre rendez-vous éventuel sera annulé.",
    "DELETE_SUBMIT": "Supprimer mon compte",
    "UPDATED": "Votre compte a été modifié.",
    "DELETED": "Votre compte a été supprimé."
  },
  "CONFIRMATION": {
    "TITLE": "Confirmation",
    "NO": "Non, revenir",
    "YES": "Oui, confirmer"
  }
}
{
  "APP": {
    "TITLE": "RdvMedecins",
    "LOGOUT": "Log out",
    "MENU_SCHEDULE": "Schedule",
    "MENU_DOCTORS": "Doctors",
    "MENU_PATIENTS": "Patients",
    "MENU_MY_AREA": "My area",
    "LOADING": "Loading...",
    "LANGUAGE": "Language"
  },
  "LOGIN": {
    "TITLE": "Login",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Password",
    "SUBMIT": "Log in",
    "ERROR": "Incorrect login or password.",
    "DEMO_ACCOUNTS": "Demo accounts (password = login):",
    "DEMO_ADMIN": "ADMIN role: appointments + doctor and patient management",
    "DEMO_DOCTOR": "DOCTOR role: booking and cancelling appointments",
    "DEMO_USER": "USER role (patients): booking for themselves, managing their account",
    "CREATE_ACCOUNT": "Create a patient account",
    "CREATE_ACCOUNT_HELP": "To create an account, first type the characters shown in the image."
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Doctor",
    "CHOOSE_DOCTOR": "-- choose a doctor --",
    "DAY_LABEL": "Day",
    "VIEW_SCHEDULE": "View schedule"
  },
  "SCHEDULE": {
    "PAGE_TITLE": "Schedule",
    "TITLE_PREFIX": "Schedule for",
    "COLUMN_SLOT": "Slot",
    "COLUMN_STATUS": "Status",
    "FREE": "Free",
    "BOOK": "Book",
    "CANCEL_APPOINTMENT": "Cancel",
    "CANCEL_CONFIRM": "Cancel this appointment?",
    "EMPTY_STATE": "Choose a doctor and a day, then click \"View schedule\".",
    "NO_SLOTS": "This doctor has no time slots.",
    "BOOKED": "Appointment booked.",
    "CANCELLED": "Appointment cancelled.",
    "BOOKED_BY_OTHER": "Booked",
    "ALREADY_BOOKED_INFO": "You already have an upcoming appointment: cancel it to book another one."
  },
  "BOOKING_DIALOG": {
    "TITLE": "Book this slot",
    "CLOSE_ARIA": "Close",
    "SLOT": "Slot {{time}}",
    "PATIENT_LABEL": "Patient",
    "CHOOSE_PATIENT": "-- choose a patient --",
    "CANCEL": "Cancel",
    "CONFIRM": "Confirm"
  },
  "PERSONS": {
    "COLUMN_TITLE": "Title",
    "COLUMN_FIRSTNAME": "First name",
    "COLUMN_LASTNAME": "Last name",
    "COLUMN_LOGIN": "Login",
    "EDIT": "Edit",
    "DELETE": "Delete",
    "SAVE": "Save",
    "BACK": "Back to the list",
    "TITLE_LABEL": "Title",
    "FIRSTNAME_LABEL": "First name",
    "LASTNAME_LABEL": "Last name",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Password",
    "LOGIN_HELP_CREATE": "Optional: defaults to the last name in lower case.",
    "LOGIN_HELP_EDIT": "Leave empty to keep it unchanged.",
    "PASSWORD_HELP_CREATE": "Optional: defaults to the login.",
    "PASSWORD_HELP_EDIT": "Leave empty to keep it unchanged.",
    "ACCOUNT_SECTION": "User account"
  },
  "DOCTORS": {
    "TITLE": "Doctors",
    "ADD": "Add a doctor",
    "EDIT": "Edit a doctor",
    "EMPTY": "No doctors.",
    "DELETE_CONFIRM": "Delete this doctor, their time slots and their user account?",
    "ADDED": "Doctor {{name}} has been added (login: {{login}}).",
    "UPDATED": "Doctor {{name}} has been updated.",
    "DELETED": "Doctor {{name}} has been deleted."
  },
  "CLIENTS": {
    "TITLE": "Patients",
    "ADD": "Add a patient",
    "EDIT": "Edit a patient",
    "EMPTY": "No patients.",
    "DELETE_CONFIRM": "Delete this patient, their user account and all their appointments?",
    "ADDED": "Patient {{name}} has been added (login: {{login}}).",
    "UPDATED": "Patient {{name}} has been updated.",
    "DELETED": "Patient {{name}} has been deleted."
  },
  "ERROR_PAGE": {
    "TITLE": "Error",
    "BACK": "Back to the home page"
  },
  "ERRORS": {
    "LOGIN_TAKEN": "This login is already used by another account.",
    "DOCTOR_ALREADY_EXISTS": "A doctor with this first and last name already exists.",
    "PATIENT_ALREADY_EXISTS": "A patient with this first and last name already exists.",
    "DOCTOR_HAS_APPOINTMENTS": "This doctor has appointments: cancel them before deleting the doctor.",
    "SLOT_ALREADY_BOOKED": "This slot has just been booked by someone else.",
    "CONCURRENT_UPDATE": "This record was changed by another user in the meantime. Go back to the list and reopen it before trying again.",
    "DOCTOR_NOT_FOUND": "This doctor does not exist (any more).",
    "PATIENT_NOT_FOUND": "This patient does not exist (any more).",
    "SLOT_NOT_FOUND": "This slot does not exist (any more).",
    "APPOINTMENT_NOT_FOUND": "This appointment does not exist (any more).",
    "INVALID_DATE": "The requested date is not valid.",
    "CHOOSE_PATIENT": "Choose a patient.",
    "INVALID_FORM": "The form contains errors.",
    "INVALID_TITLE": "Choose a title from the list.",
    "FIRSTNAME_REQUIRED": "The first name is required.",
    "FIRSTNAME_TOO_LONG": "The first name must not exceed 20 characters.",
    "LASTNAME_REQUIRED": "The last name is required.",
    "LASTNAME_TOO_LONG": "The last name must not exceed 20 characters.",
    "INVALID_LOGIN": "At most 30 characters: unaccented lower-case letters, digits, dot, hyphen, underscore.",
    "PASSWORD_TOO_LONG": "The password must not exceed 72 characters.",
    "SESSION_EXPIRED": "Your session has expired: please log in again.",
    "BAD_REQUEST": "The request is invalid.",
    "FORBIDDEN": "Your role does not allow you to access this page.",
    "NOT_FOUND": "This page does not exist.",
    "SERVER_ERROR": "An unexpected error occurred. Please try again later.",
    "TOO_MANY_ATTEMPTS": "Too many failed attempts. Try again in {{minutes}} minute(s).",
    "WRONG_CAPTCHA": "The characters you typed do not match the image. A new image is shown.",
    "TOO_MANY_ACCOUNTS": "Too many accounts have been created from your connection. Try again in {{minutes}} minute(s).",
    "LOGIN_REQUIRED": "The login is required.",
    "PASSWORD_REQUIRED": "The password is required.",
    "PASSWORD_TOO_SHORT": "The password must be at least {{min}} characters long.",
    "CONFIRMATION_REQUIRED": "Please confirm the password.",
    "PASSWORDS_DIFFER": "The confirmation does not match the password.",
    "CURRENT_PASSWORD_REQUIRED": "Enter your current password.",
    "WRONG_CURRENT_PASSWORD": "Incorrect current password.",
    "PAST_DATE": "Appointments cannot be booked for a past date.",
    "PATIENT_HAS_UPCOMING_APPOINTMENT": "This patient already has an upcoming appointment: it must be cancelled before booking another one.",
    "CAPTCHA_BEFORE_ACCOUNT": "To create an account, first type the characters shown in the image correctly, then click \"Create a patient account\".",
    "AUTH_REQUIRED": "Please log in to access this page.",
    "JSON_REQUIRED": "Request refused: the server expects JSON.",
    "SERVER_UNREACHABLE": "The server does not respond. Please try again later."
  },
  "CAPTCHA": {
    "LABEL": "Type the characters shown in the image",
    "IMAGE_ALT": "Anti-robot verification image",
    "NEW_IMAGE": "Another image",
    "HELP": "Upper or lower case, it does not matter."
  },
  "REGISTRATION": {
    "TITLE": "Create a patient account",
    "INTRO": "With this account you can book your own appointments.",
    "LOGIN_HELP": "Unaccented lower-case letters, digits, dot, hyphen, underscore.",
    "PASSWORD_HELP": "At least {{min}} characters.",
    "SUBMIT": "Create my account",
    "BACK_TO_LOGIN": "Back to login",
    "DONE": "Your account has been created. You can now log in with the login {{login}}."
  },
  "ACCOUNT": {
    "CONFIRMATION_LABEL": "Confirm password"
  },
  "AREA": {
    "TITLE": "My area",
    "HELLO": "Hello {{name}}",
    "MANAGE_ACCOUNT": "Manage my account",
    "MANAGE_ACCOUNT_HELP": "Change my details or password, or delete my account.",
    "VIEW_SCHEDULE": "View a schedule",
    "VIEW_SCHEDULE_HELP": "See a doctor's schedule and book a slot.",
    "MY_APPOINTMENT": "My appointment",
    "SEE_IN_SCHEDULE": "see in the schedule",
    "CANCEL_APPOINTMENT": "Cancel this appointment",
    "NO_APPOINTMENT": "You have no upcoming appointment."
  },
  "MY_ACCOUNT": {
    "TITLE": "Manage my account",
    "NEW_PASSWORD_LABEL": "New password",
    "CURRENT_PASSWORD_LABEL": "Current password",
    "CURRENT_PASSWORD_HELP": "Required to save any change.",
    "BACK": "Back to my area",
    "DELETE_TITLE": "Delete my account",
    "DELETE_HELP": "Your account will be permanently deleted, together with all your appointments.",
    "DELETE_CONFIRM": "Permanently delete your account? Any appointment you have will be cancelled.",
    "DELETE_SUBMIT": "Delete my account",
    "UPDATED": "Your account has been updated.",
    "DELETED": "Your account has been deleted."
  },
  "CONFIRMATION": {
    "TITLE": "Confirmation",
    "NO": "No, go back",
    "YES": "Yes, confirm"
  }
}

10.4.5. Los servicios

10.4.5.1. src/app/services/session.service.ts

// =========================================================================
// services/session.service.ts - ¿QUIÉN ha iniciado sesión?
// -------------------------------------------------------------------------
// El usuario que ha iniciado sesión (o null), y lo que se deduce de él (¿es el ADMIN?
// ¿un paciente?), en un servicio raíz basado en signals (ver ejemplo 20).
//
// El token JWT en sí NO está aquí: está en una cookie httpOnly que
// solo maneja el navegador. El servicio solo conserva la DESCRIPCIÓN
// del usuario, devuelta por el servidor ({ login, name, role }).
//
// Al iniciar (y tras un F5), el servicio está vacío: check() le pregunta
// al servidor, una sola vez, quién ha iniciado sesión (GET /api/auth/me).
// =========================================================================

import { computed, inject, Injectable, signal } from '@angular/core';
import { RdvMedecinsApi } from '../api/rdvmedecins.api';
import { Role, User } from '../api/types';

@Injectable({ providedIn: 'root' })
export class SessionService {
  private readonly api = inject(RdvMedecinsApi);
  private readonly _user = signal<User | null>(null);
  // ¿ya se le hizo al servidor la pregunta "¿quién ha iniciado sesión?"?
  private checking: Promise<void> | null = null;

  readonly user = this._user.asReadonly();
  readonly loggedIn = computed(() => this._user() !== null);
  readonly role = computed<Role | null>(() => this._user()?.role ?? null);
  readonly isAdmin = computed(() => this.role() === 'ADMIN');
  readonly isPatient = computed(() => this.role() === 'USER');
  // ADMIN y DOCTOR: reservar y cancelar las citas de cualquier paciente
  readonly isManager = computed(() => this.role() === 'ADMIN' || this.role() === 'DOCTOR');

  // la página de inicio de cada rol, justo después del login
  readonly homePage = computed(() => (this.isPatient() ? '/my-area' : '/schedule'));

  // llamado por el guard del enrutador antes de CADA navegación; solo consulta
  // al servidor la primera vez (la promesa se conserva y se reutiliza)
  check(): Promise<void> {
    this.checking ??= this.api
      .me()
      .then((u) => this._user.set(u))
      .catch(() => this._user.set(null)); // 401: nadie; o servidor inaccesible
    return this.checking;
  }

  async logIn(login: string, password: string, captchaId: string, captcha: string): Promise<void> {
    this._user.set(await this.api.logIn(login, password, captchaId, captcha));
  }

  // el usuario ha cambiado de nombre o de login (PUT /api/my-account)
  update(u: User): void {
    this._user.set(u);
  }

  async logOut(): Promise<void> {
    try {
      await this.api.logOut();
    } finally {
      this.forget();
    }
  }

  // sin preguntarle nada al servidor: sesión expirada, cuenta eliminada
  forget(): void {
    this._user.set(null);
  }
}

El usuario con sesión iniciada, en un servicio de señales (ejemplo 20):

  • línea 22: el estado: el usuario, o [null]. El token en sí no está aquí: está en una cookie que solo maneja el navegador;
  • líneas 26–32: lo que leen los componentes: el usuario y lo que se deduce de él (¿ha iniciado sesión? ¿es ADMIN? ¿es un paciente?);
  • línea 35: la página de inicio de cada rol;
  • líneas 39–45: al iniciar (y después de un F5), el servicio no sabe quién ha iniciado sesión: se lo pregunta al servidor. [check] es llamado por la guardia del enrutador antes de CADA navegación, pero solo consulta al servidor la primera vez: la promesa se conserva (línea 40, [??=]: «si aún no existe») y se devuelve en cada llamada posterior. Si dos navegaciones se suceden muy de cerca, esperan la misma respuesta;
  • línea 43: 401 (nadie) o servidor inaccesible: sin usuario;
  • líneas 56–62: cierre de sesión; [finally]: se olvida al usuario aunque el servidor no responda;
  • líneas 65–67: olvidar al usuario sin enviar ninguna solicitud al servidor: es lo que hace el interceptor ante un 401.

10.4.5.2. src/app/services/messages.service.ts

// =========================================================================
// services/messages.service.ts - los mensajes mostrados al usuario
// -------------------------------------------------------------------------
// La misma presentación que la aplicación HTML:
//   - un ÉXITO se muestra ARRIBA de la página (banner verde);
//   - un ERROR ABAJO, sobre un fondo rosa claro (panel "fijo").
// Un mensaje es una CLAVE de traducción (+ sus parámetros): por lo tanto se traduce
// de nuevo por sí solo si el usuario cambia de idioma.
//
// Los mensajes "flash": una acción que termina con un cambio de
// página (reserva, alta de un médico...) deja su mensaje con flash();
// se mostrará en la página SIGUIENTE, y luego desaparecerá en la
// navegación posterior. El servicio lo sabe porque escucha los eventos del enrutador
// (fin de cada navegación). Del lado del servidor, ese era el papel de la
// cookie de corta duración "rdvmedecins_flash".
// =========================================================================

import { Injectable, inject, signal } from '@angular/core';
import { NavigationEnd, Router } from '@angular/router';
import { ApiError } from '../api/api-error';

export interface Message {
  key: string;
  params?: Record<string, string>;
}

@Injectable({ providedIn: 'root' })
export class MessagesService {
  readonly success = signal<Message | null>(null);
  readonly error = signal<Message | null>(null);
  // los mensajes que se mostrarán en la página siguiente
  private pending: { success: Message | null; error: Message | null } | null = null;

  constructor() {
    // una nueva página (incluso cuando solo cambia la query, /schedule?...):
    // los mensajes de la página anterior desaparecen, los mensajes flash
    // aparecen. Un servicio raíz vive tanto como la aplicación:
    // no hace falta cancelar la suscripción.
    inject(Router).events.subscribe((e) => {
      if (e instanceof NavigationEnd) {
        this.newPage();
      }
    });
  }

  showSuccess(key: string, params?: Record<string, string>): void {
    this.success.set({ key, params });
    this.error.set(null);
  }

  showError(key: string, params?: Record<string, string>): void {
    this.error.set({ key, params });
    this.success.set(null);
  }

  // un ApiError -> el mensaje de la página; cualquier otro error es una
  // anomalía del cliente, que se deja pasar (consola del navegador)
  showApiError(e: unknown): void {
    if (!(e instanceof ApiError)) {
      throw e;
    }
    this.showError(e.key, e.params);
  }

  clear(): void {
    this.success.set(null);
    this.error.set(null);
  }

  // para la página SIGUIENTE
  flash(type: 'success' | 'error', key: string, params?: Record<string, string>): void {
    this.pending ??= { success: null, error: null };
    this.pending[type] = { key, params };
  }

  private newPage(): void {
    this.success.set(this.pending?.success ?? null);
    this.error.set(this.pending?.error ?? null);
    this.pending = null;
  }
}

Mensajes mostrados al usuario, como en la aplicación HTML: un mensaje de éxito en la parte superior de la página y un mensaje de error en la parte inferior. Un mensaje es una clave de traducción: se traduce automáticamente si el usuario cambia de idioma.

  • Líneas 29–30: los dos mensajes de la página actual;
  • líneas 58–63: un [ApiError] se convierte en el mensaje de error de la página; cualquier otro error es un problema del lado del cliente, que se permite informar;
  • líneas 71–74: un mensaje flash para la página siguiente. Una acción que termina con un cambio de página (un médico agregado, el regreso a la lista) muestra así su mensaje;
  • líneas 39–43: el servicio escucha los eventos del enrutador (ejemplo 17). Al final de cada navegación (líneas 76–80), los mensajes de la página anterior desaparecen y aparecen los mensajes flash. En el servidor, este era el papel de una cookie de corta duración.

10.4.5.3. src/app/services/confirmation.service.ts

// =========================================================================
// services/confirmation.service.ts - "¿Está seguro?"
// -------------------------------------------------------------------------
// Tomado del ejemplo 16: confirm(key) abre el diálogo de confirmación
// (components/confirm-dialog.ts, colocado una vez en App) y devuelve
// una promesa resuelta a true (Sí) o false (No). El mensaje es una
// CLAVE de traducción: el diálogo la traduce al idioma actual.
//
//     if (await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM')) { ... }
// =========================================================================

import { inject, Injectable, signal } from '@angular/core';
import { MessagesService } from './messages.service';

@Injectable({ providedIn: 'root' })
export class ConfirmationService {
  private readonly messages = inject(MessagesService);
  private readonly _messageKey = signal<string | null>(null); // null: diálogo cerrado
  readonly messageKey = this._messageKey.asReadonly();
  private answer: ((yes: boolean) => void) | null = null;

  confirm(key: string): Promise<boolean> {
    this.answer?.(false); // ¿una pregunta aún abierta? cuenta como "no"
    // una nueva pregunta: los mensajes de la acción anterior quedan obsoletos
    this.messages.clear();
    this._messageKey.set(key);
    return new Promise<boolean>((resolve) => {
      this.answer = resolve;
    });
  }

  respond(yes: boolean): void {
    this._messageKey.set(null);
    const r = this.answer;
    this.answer = null;
    r?.(yes);
  }
}

El servicio del Ejemplo 16. El mensaje ahora es una clave de traducción (línea 18) y una nueva pregunta borra los mensajes de la acción anterior (línea 25).

10.4.5.4. src/app/services/form-submission.ts

// =========================================================================
// services/form-submission.ts - enviar un formulario al servidor
// -------------------------------------------------------------------------
// Todos los formularios de la aplicación siguen el mismo patrón que el
// ejemplo 25: no se verifica ninguna regla en el navegador (viven
// en UN solo lugar, el servidor), y en caso de rechazo:
//   - el error de cada campo (ApiError.fields) se adjunta al campo del
//     formulario con signals, que lo muestra con borde rojo;
//   - el mensaje general (ApiError.key) se muestra al pie de la página.
// Esta clase agrupa estos pasos. Una página crea una por formulario:
//
//     protected readonly submission = new FormSubmission(this.f);
//     if (await this.submission.submit(() => this.api.register(this.model()))) { ... }
//
// Se usa en un contexto de inyección (inicialización de un campo
// de la clase del componente): allí obtiene el servicio de mensajes.
// =========================================================================

import { inject, signal } from '@angular/core';
import { FieldTree, isFieldTree, submit, ValidationError } from '@angular/forms/signals';
import { ApiError } from '../api/api-error';
import { MessagesService } from './messages.service';

export class FormSubmission<T> {
  private readonly messages = inject(MessagesService);
  // los parámetros de los mensajes de error ({min}...), devueltos por el servidor
  readonly params = signal<Record<string, string>>({});

  constructor(private readonly form: FieldTree<T>) {}

  // ejecuta el envío; devuelve true si tuvo éxito. Ante un ApiError, se
  // muestran los errores y se devuelve false.
  // ignoreValidators: envía aunque no se cumplan las reglas del esquema del formulario
  // (si las tiene)
  async submit(action: () => Promise<unknown>, ignoreValidators = false): Promise<boolean> {
    this.params.set({});
    let succeeded = false;
    await submit(this.form, {
      ignoreValidators: ignoreValidators ? 'all' : 'pending',
      action: async () => {
        try {
          await action();
          succeeded = true;
          return null; // sin error
        } catch (e) {
          this.messages.showApiError(e); // (vuelve a lanzar cualquier error que no sea un ApiError)
          const error = e as ApiError;
          this.params.set(error.params);
          return this.fieldErrors(error);
        }
      },
    });
    return succeeded;
  }

  // { lastName: 'ERRORS.LASTNAME_REQUIRED' } -> un error asociado al campo f.lastName
  private fieldErrors(e: ApiError): ValidationError.WithOptionalFieldTree[] {
    const fields = this.form as unknown as Record<string, unknown>;
    return Object.entries(e.fields)
      .filter(([name]) => isFieldTree(fields[name]))
      .map(([name, key]) => ({ kind: 'server', message: key, fieldTree: fields[name] as FieldTree<unknown> }));
  }
}

Todos los formularios de la aplicación siguen el patrón mostrado en el Ejemplo 25: el servidor valida las reglas y, si se rechaza un formulario, el error de cada campo se muestra debajo de ese campo, con un mensaje de error general en la parte inferior de la página. Esta clase agrupa estas acciones para que no haya que repetirlas en cada página:

  • línea 24: una clase genérica: [T] es el tipo del modelo del formulario;
  • línea 25: [inject] en la inicialización de un campo: la clase debe crearse en un contexto de inyección, es decir, durante la inicialización de un campo del componente (línea 12);
  • línea 27: los parámetros de los mensajes de error ([{{min}}]...), devueltos por el servidor;
  • líneas 35–54: el envío. [submit] (ejemplo 25) ejecuta la acción; el método devuelve [true] si la acción tuvo éxito;
  • línea 39: [ignoreValidators]: por defecto (['pending']), [submit] no ejecuta la acción si el formulario tiene errores de validación (la página de inicio de sesión tiene un esquema con dos campos obligatorios). ['all']: envía la solicitud de todos modos (véase la página de inicio de sesión);
  • línea 46: el mensaje general;
  • líneas 57–62: errores de campo. [isFieldTree] verifica que el formulario tenga efectivamente un campo con ese nombre: el servidor puede informar de un error en un campo que el formulario no muestra.

10.4.6. Formato

10.4.6.1. src/app/pipes/formatting.ts

// =========================================================================
// pipes/formatting.ts - la presentación de personas, horas y días
// -------------------------------------------------------------------------
// El servidor envía datos CRUDOS (startHour: 8, startMinute: 0; day:
// "2026-10-05"); el formato, que depende del idioma, es responsabilidad
// del cliente. Funciones, usadas por el código, y pipes (archivo
// formatting.pipes.ts), usados por las plantillas.
// =========================================================================

import { Slot, Identity } from '../api/types';

// "Mme Alice DURAND"
export function label(p: Identity): string {
  return `${p.title} ${p.firstName} ${p.lastName}`;
}

// "8:05" en lugar de "8:5"
export function time(h: number, m: number): string {
  return `${h}:${String(m).padStart(2, '0')}`;
}

// "8:00 - 8:20"
export function timeRange(s: Slot): string {
  return `${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}`;
}

// la fecha de hoy, en el formato "yyyy-MM-dd" (el de <input type="date"> y el de la API)
export function today(): string {
  const d = new Date();
  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
}

// true si [day] es una fecha que existe, en el formato yyyy-MM-dd
export function isValidDate(day: unknown): day is string {
  if (typeof day !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(day)) {
    return false;
  }
  const date = new Date(`${day}T00:00:00Z`);
  return !isNaN(date.getTime()) && date.toISOString().slice(0, 10) === day;
}

// "lundi 5 octobre 2026" / "Monday 5 October 2026"
export function longDate(day: string, language: string | null): string {
  return new Intl.DateTimeFormat(language === 'en' ? 'en-GB' : 'fr-FR', {
    dateStyle: 'full',
    timeZone: 'UTC', // "2026-10-05T00:00:00Z" debe seguir siendo el 5, sin importar la zona horaria
  }).format(new Date(`${day}T00:00:00Z`));
}

El servidor envía datos sin procesar ([startHour: 8, startMinute: 0]; [day: "2026-10-05"]); el formato, que depende del idioma, es responsabilidad del cliente:

  • líneas 34–40: ¿es una fecha válida? [2026-02-30] tiene el formato correcto, pero no existe: [new Date] la convertiría en el 2 de marzo. Por eso verificamos que se lea de forma idéntica. [day is string]: si la función devuelve true, [TypeScript] sabe que [day] es una cadena;
  • líneas 43–48: [Intl.DateTimeFormat], proporcionado por el navegador, escribe la fecha en el idioma solicitado. La zona horaria UTC evita que un navegador ubicado al oeste de Greenwich muestre el día anterior.

10.4.6.2. src/app/pipes/formatting.pipes.ts

// =========================================================================
// pipes/formatting.pipes.ts - las funciones de formatting.ts, como pipes
// -------------------------------------------------------------------------
//     {{ doctor | label }}                 "Mme Marie PELISSIER"
//     {{ slot | timeRange }}               "8:00 - 8:20"
//     {{ day | longDate: language() }}     "Monday 5 October 2026"
// longDate recibe el idioma como parámetro: un pipe puro se recalcula solo
// si cambia uno de sus argumentos; por lo tanto, cambiar el idioma lo recalcula.
// =========================================================================

import { Pipe, PipeTransform } from '@angular/core';
import { Slot, Identity } from '../api/types';
import { timeRange, longDate, label } from './formatting';

@Pipe({ name: 'label' })
export class LabelPipe implements PipeTransform {
  transform(p: Identity): string {
    return label(p);
  }
}

@Pipe({ name: 'timeRange' })
export class TimeRangePipe implements PipeTransform {
  transform(s: Slot): string {
    return timeRange(s);
  }
}

@Pipe({ name: 'longDate' })
export class LongDatePipe implements PipeTransform {
  transform(day: string, language: string | null): string {
    return longDate(day, language);
  }
}

Las mismas funciones, como pipes, para las plantillas. [longDate] recibe el idioma como parámetro: un pipe puro (ejemplo 09) se vuelve a calcular solo si cambia uno de sus argumentos; por lo tanto, cambiar el idioma provoca un nuevo cálculo.

10.4.7. El enrutador

10.4.7.1. src/app/app.routes.ts

// =========================================================================
// app.routes.ts - las páginas de la aplicación y sus derechos de acceso
// -------------------------------------------------------------------------
// Las MISMAS direcciones que la aplicación HTML (/login, /schedule, /doctors,
// /my-area...), pero ahora son rutas del CLIENTE. El
// navegador envía una solicitud al servidor solo para la primera
// página; luego, el enrutador cambia la dirección y el componente mostrado.
//
// La contrapartida: si el usuario recarga /schedule (F5), el
// navegador sí solicita /schedule al servidor, que entonces debe
// devolver index.html (ng serve lo hace en desarrollo; en producción,
// vea web/client-spa.ts del servidor JSON).
//
// Todas las páginas son HIJAS de una ruta sin componente,
// que lleva el guardia sessionGuard (canActivateChild): así se aplica
// a cada una de ellas. Cada ruta declara:
//   - title: clave de traducción del título de la pestaña (vea i18n/title.strategy.ts);
//   - data : public (accesible sin haber iniciado sesión), roles (los
//             roles permitidos), type ('doctors' o 'clients'), code (403, 404).
// Gracias a withComponentInputBinding (app.config.ts), los parámetros de
// la dirección (:id, ?day=...) Y los datos (type, code) llegan a los
// INPUTS de los componentes de las páginas.
// =========================================================================

import { Routes } from '@angular/router';
import { PersonType } from './api/rdvmedecins.api';
import { Role } from './api/types';
import { registrationGuard, sessionGuard, numericId } from './guards';
import { LoginPage } from './pages/login/login';
import { SchedulePage } from './pages/schedule/schedule';

// las rutas que gestionan los médicos Y los clientes (ADMIN), con el mismo
// modelo; las páginas se cargan bajo demanda (loadComponent)
function personRoutes(type: PersonType, title: string, addTitle: string, editTitle: string): Routes {
  const data = { roles: ['ADMIN'] as Role[], type };
  return [
    { path: type, loadComponent: () => import('./pages/persons/persons'), title: title, data },
    { path: `${type}/add`, loadComponent: () => import('./pages/person-form/person-form'), title: addTitle, data },
    {
      path: `${type}/:id/edit`,
      canMatch: [numericId],
      loadComponent: () => import('./pages/person-form/person-form'),
      title: editTitle,
      data,
    },
  ];
}

export const routes: Routes = [
  {
    path: '',
    canActivateChild: [sessionGuard],
    children: [
      // "/": hacia /login, que a su vez va a la página de inicio del rol si hay sesión iniciada
      { path: '', pathMatch: 'full', redirectTo: 'login' },
      { path: 'login', component: LoginPage, title: 'LOGIN.TITLE', data: { public: true } },
      { path: 'schedule', component: SchedulePage, title: 'SCHEDULE.PAGE_TITLE' },
      ...personRoutes('doctors', 'DOCTORS.TITLE', 'DOCTORS.ADD', 'DOCTORS.EDIT'),
      ...personRoutes('clients', 'CLIENTS.TITLE', 'CLIENTS.ADD', 'CLIENTS.EDIT'),
      {
        path: 'register',
        loadComponent: () => import('./pages/register/register'),
        title: 'REGISTRATION.TITLE',
        data: { public: true },
        canActivate: [registrationGuard],
      },
      {
        path: 'my-area',
        loadComponent: () => import('./pages/patient-area/patient-area'),
        title: 'AREA.TITLE',
        data: { roles: ['USER'] },
      },
      {
        path: 'my-account',
        loadComponent: () => import('./pages/my-account/my-account'),
        title: 'MY_ACCOUNT.TITLE',
        data: { roles: ['USER'] },
      },
      { path: 'forbidden', loadComponent: () => import('./pages/error/error'), title: 'ERROR_PAGE.TITLE', data: { code: 403 } },
      {
        path: '**',
        loadComponent: () => import('./pages/error/error'),
        title: 'ERROR_PAGE.TITLE',
        data: { code: 404, public: true },
      },
    ],
  },
];

Las mismas URL que la aplicación HTML (/login, /schedule, /doctors, /my-area...), pero ahora son rutas del cliente:

  • líneas 50–53: todas las páginas son hijas ([children]) de una ruta sin componente, que lleva la guardia [sessionGuard]: [canActivateChild] se la aplica a cada una sin tener que repetirla;
  • línea 55: la dirección / lleva a la página de inicio de sesión, que a su vez redirige a la página de inicio del rol si el usuario ha iniciado sesión;
  • líneas 56–57: las dos páginas más visitadas forman parte del archivo principal; las demás se cargan bajo demanda ([loadComponent]);
  • [title]: la clave de traducción del título de la pestaña;
  • [data]: [public] (accesible sin haber iniciado sesión), [roles] (roles autorizados; ausente: todos los roles con sesión iniciada), [type] (['doctors'] o ['clients']), [code] (403, 404). Gracias a [withComponentInputBinding], los datos de la ruta también se pasan a las entradas del componente de la página, al igual que los parámetros de la dirección;
  • líneas 34–47: las tres rutas del sistema de gestión de médicos y las del sistema de gestión de clientes las genera la misma función: ambos sistemas usan las mismas páginas, con un [type] diferente;
  • línea 41: [canMatch]: una guardia que determina si la ruta coincide con la dirección. Si falla, el enrutador prueba las rutas siguientes: /doctors/abc/edit lleva así a una página 404;
  • línea 65: una guardia específica de la página de creación de cuenta;
  • línea 79: la página 403, a la que redirige la guardia;
  • líneas 80–85: cualquier otra dirección: la página 404.

10.4.7.2. src/app/guards.ts

// =========================================================================
// guards.ts - los guardias del enrutador
// -------------------------------------------------------------------------
// sessionGuard: el guardia de TODAS las páginas (vea app.routes.ts). Antes de
// cada navegación:
//   1. la primera vez (arranque, F5), pregunta al servidor quién ha
//      iniciado sesión (SessionService.check);
//   2. verifica los derechos descritos en los datos de la ruta:
//        - public: accesible sin haber iniciado sesión;
//        - roles : los roles permitidos (ausente = todos los roles con sesión iniciada).
//
// RECORDATORIO: estas verificaciones son solo una COMODIDAD (no mostrar una
// página inútil). La protección de los datos la garantiza el servidor, que
// vuelve a verificar el token y el rol en CADA solicitud.
//
// ADVERTENCIA: inject() solo se permite al INICIO de un guardia, antes de cualquier
// await (después, se pierde el "contexto de inyección").
// =========================================================================

import { inject } from '@angular/core';
import { CanActivateChildFn, CanActivateFn, CanMatchFn, Router } from '@angular/router';
import { Role } from './api/types';
import { RdvMedecinsApi } from './api/rdvmedecins.api';
import { SessionService } from './services/session.service';
import { MessagesService } from './services/messages.service';

export const sessionGuard: CanActivateChildFn = async (route, state) => {
  const session = inject(SessionService);
  const router = inject(Router);
  await session.check();

  if (route.data['public']) {
    // ya inició sesión: la página de inicio de sesión ya no tiene sentido
    if (route.routeConfig?.path === 'login' && session.loggedIn()) {
      return router.parseUrl(session.homePage());
    }
    return true;
  }
  if (!session.loggedIn()) {
    // se recuerda la página solicitada, para volver a ella después de iniciar sesión
    return router.createUrlTree(['/login'], { queryParams: { redirect: state.url } });
  }
  const roles = route.data['roles'] as Role[] | undefined;
  if (roles && !roles.includes(session.role()!)) {
    return router.createUrlTree(['/forbidden']);
  }
  return true;
};

// un guardia ESPECÍFICO de la ruta /register: sin un pase (captcha
// resuelto en la página de inicio de sesión), se vuelve a la página de inicio de sesión
export const registrationGuard: CanActivateFn = async () => {
  const api = inject(RdvMedecinsApi);
  const messages = inject(MessagesService);
  const router = inject(Router);
  const { valid } = await api.registrationAccessStatus().catch(() => ({ valid: false }));
  if (!valid) {
    messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
    return router.createUrlTree(['/login']);
  }
  return true;
};

// /doctors/3/edit: la ruta COINCIDE solo si el 2.º segmento de
// la dirección es un número (/doctors/abc/edit lleva a la página 404)
export const numericId: CanMatchFn = (_route, segments) => /^\d+$/.test(segments[1]?.path ?? '');
  • Línea 27: una guardia puede ser [async]: el enrutador espera su respuesta;
  • Líneas 28–30: ATENCIÓN: [inject] solo se permite al principio de la guardia, antes de cualquier [await]; después, se pierde el contexto de inyección;
  • línea 30: la primera vez, se le pregunta al servidor quién ha iniciado sesión;
  • líneas 32–38: una página pública; pero la página de inicio de sesión ya no tiene sentido para un usuario que ya inició sesión (línea 34). [parseUrl] convierte una dirección en un [UrlTree], el valor que desencadena una redirección;
  • líneas 39–42: sin sesión iniciada: a la página de inicio de sesión, conservando la página solicitada;
  • líneas 43–46: un rol no válido: redirige a la página 403;
  • líneas 52–62: crear una cuenta requiere un «pase», obtenido al resolver el CAPTCHA en la página de inicio de sesión. Sin él, se devuelve al usuario a la página de inicio de sesión con un mensaje;
  • línea 66: la guardia [canMatch] recibe los segmentos de la dirección: [['doctors', '3', 'edit']].

Estas guardias son solo una comodidad: la protección de los datos la garantiza el servidor, que vuelve a verificar el token y el rol en cada solicitud.

10.4.8. Los componentes

10.4.8.1. src/app/components/nav-bar

// =========================================================================
// components/nav-bar/nav-bar.ts - la barra de navegación
// -------------------------------------------------------------------------
// Mismo contenido que el de la aplicación HTML (views/partials/navbar.hbs):
// título, menús según el rol, FR / EN, rol, nombre, cierre de sesión.
// "Doctors" y "Patients" aparecen solo para el ADMIN: una simple
// comodidad de visualización, ya que la protección real es la del servidor.
// =========================================================================

import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { SessionService } from '../../services/session.service';
import { LanguageService } from '../../i18n/language.service';
import { LANGUAGES } from '../../i18n/i18n';

@Component({
  selector: 'app-nav-bar',
  imports: [RouterLink, RouterLinkActive, TranslatePipe],
  templateUrl: './nav-bar.html',
})
export class NavBar {
  protected readonly session = inject(SessionService);
  protected readonly languages = inject(LanguageService);
  protected readonly LANGUAGES = LANGUAGES;
  private readonly router = inject(Router);

  protected async logOut(): Promise<void> {
    await this.session.logOut().catch(() => {}); // incluso si el servidor no responde
    this.router.navigate(['/login']);
  }
}
  • Línea 29: cierra la sesión, aunque el servidor no responda; luego vuelve a la página de inicio de sesión.
<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>

  @if (session.loggedIn()) {
    <ul class="navbar-nav me-auto">
      @if (session.isPatient()) {
        <li class="nav-item">
          <!-- routerLinkActive: la clase de Bootstrap del menú de la página mostrada -->
          <a class="nav-link" routerLink="/my-area" routerLinkActive="active">{{ 'APP.MENU_MY_AREA' | translate }}</a>
        </li>
      }
      <li class="nav-item">
        <a class="nav-link" routerLink="/schedule" routerLinkActive="active">{{ 'APP.MENU_SCHEDULE' | translate }}</a>
      </li>
      @if (session.isAdmin()) {
        <li class="nav-item">
          <a class="nav-link" routerLink="/doctors" routerLinkActive="active">{{ 'APP.MENU_DOCTORS' | translate }}</a>
        </li>
        <li class="nav-item">
          <a class="nav-link" routerLink="/clients" routerLinkActive="active">{{ 'APP.MENU_PATIENTS' | translate }}</a>
        </li>
      }
    </ul>
  } @else {
    <div class="me-auto"></div>
  }

  <div class="d-flex align-items-center gap-2">
    <!-- FR / EN: sin solicitud al servidor, la página se traduce de nuevo en el lugar -->
    <div class="btn-group btn-group-sm" role="group" [attr.aria-label]="'APP.LANGUAGE' | translate">
      @for (l of LANGUAGES; track l) {
        <button type="button" class="btn" [class]="languages.language() === l ? 'btn-light' : 'btn-outline-light'"
                [attr.aria-pressed]="languages.language() === l" (click)="languages.change(l)">
          {{ l.toUpperCase() }}
        </button>
      }
    </div>

    @if (session.user(); as u) {
      <span class="badge text-bg-light text-primary">{{ u.role }}</span>
      <span class="text-white">{{ u.name }}</span>
      <button type="button" class="btn btn-sm btn-outline-light" (click)="logOut()">{{ 'APP.LOGOUT' | translate }}</button>
    }
  </div>
</nav>
  • Líneas 4–23: los menús, según el rol;
  • líneas 31–36: los botones FR / EN; [aria-pressed] indica a los lectores de pantalla qué botón está presionado;
  • líneas 39–43: rol, nombre, cierre de sesión.

10.4.8.2. src/app/components/success-message.ts y error-panel.ts

// =========================================================================
// components/success-message.ts - el mensaje de ÉXITO, en la parte superior de la página
// (cita reservada, médico agregado...) - vea services/messages.service.ts.
// role="status": un lector de pantalla lo anuncia sin interrumpir al usuario.
// =========================================================================

import { Component, inject } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { MessagesService } from '../services/messages.service';

@Component({
  selector: 'app-success-message',
  imports: [TranslatePipe],
  template: `
    @if (messages.success(); as m) {
      <div class="alert alert-success" role="status">{{ m.key | translate: m.params }}</div>
    }
  `,
})
export class SuccessMessage {
  protected readonly messages = inject(MessagesService);
}
// =========================================================================
// components/error-panel.ts - el panel de errores, en la parte INFERIOR de cada página, sobre
// un fondo rosa claro (clase .error-panel, vea styles.css) - como
// views/partials/errors.hbs de la aplicación HTML.
// role="alert": un lector de pantalla anuncia el mensaje en cuanto aparece.
// =========================================================================

import { Component, inject } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { MessagesService } from '../services/messages.service';

@Component({
  selector: 'app-error-panel',
  imports: [TranslatePipe],
  template: `
    @if (messages.error(); as m) {
      <div class="error-panel" role="alert">{{ m.key | translate: m.params }}</div>
    }
  `,
})
export class ErrorPanel {
  protected readonly messages = inject(MessagesService);
}

Dos pequeños componentes que muestran los mensajes del servicio [MessagesService], traducidos junto con sus parámetros. Los roles [status] y [alert] hacen que los lectores de pantalla anuncien los mensajes.

10.4.8.3. src/app/components/confirm-dialog

// =========================================================================
// components/confirm-dialog/confirm-dialog.ts
// -------------------------------------------------------------------------
// El diálogo "Are you sure?" del ejemplo 16, completado para el teclado
// como public/js/app.js de la aplicación HTML:
//   - al abrirse, el foco va a "No, go back": una pulsación distraída de
//     Enter no elimina nada;
//   - Escape cierra el diálogo (= No);
//   - Tab y Shift+Tab se quedan DENTRO del diálogo (de lo contrario el foco iría a
//     la página atenuada, detrás);
//   - al cerrarse, el foco vuelve al elemento que lo tenía (el
//     botón "Delete" en el que se hizo clic, por ejemplo).
// "No, go back" en lugar de "Cancel": la pregunta a veces es "Cancel this
// appointment?", y un botón "Cancel" sería ambiguo en ese caso.
// =========================================================================

import { Component, effect, ElementRef, inject, untracked, viewChild } from '@angular/core';
import { TranslatePipe } from '@ngx-translate/core';
import { ConfirmationService } from '../../services/confirmation.service';

@Component({
  selector: 'app-confirm-dialog',
  imports: [TranslatePipe],
  templateUrl: './confirm-dialog.html',
})
export class ConfirmDialog {
  protected readonly confirmation = inject(ConfirmationService);
  private readonly dialog = viewChild<ElementRef<HTMLElement>>('dialog');
  private readonly noButton = viewChild<ElementRef<HTMLButtonElement>>('noButton');
  private previousFocus: HTMLElement | null = null;

  constructor() {
    // el diálogo se abre (aparece el botón "No") o se cierra
    effect(() => {
      const button = this.noButton();
      untracked(() => {
        if (button) {
          this.previousFocus = document.activeElement as HTMLElement | null;
          button.nativeElement.focus();
        } else {
          this.previousFocus?.focus();
          this.previousFocus = null;
        }
      });
    });
  }

  protected onKeydown(e: KeyboardEvent): void {
    const dialog = this.dialog()?.nativeElement;
    if (e.key === 'Escape') {
      this.confirmation.respond(false);
    } else if (e.key === 'Tab' && dialog) {
      const buttons = [...dialog.querySelectorAll<HTMLButtonElement>('button')];
      const first = buttons[0];
      const last = buttons[buttons.length - 1];
      if (e.shiftKey && document.activeElement === first) {
        e.preventDefault();
        last?.focus();
      } else if (!e.shiftKey && document.activeElement === last) {
        e.preventDefault();
        first?.focus();
      }
    }
  }

  // un clic en el fondo atenuado (y no en el diálogo mismo) = No
  protected onBackdropClick(e: MouseEvent): void {
    if (e.target === e.currentTarget) {
      this.confirmation.respond(false);
    }
  }
}

La ventana del Ejemplo 16, con soporte de teclado agregado:

  • líneas 34–45: un efecto que sigue la aparición y desaparición del botón «No». Al abrirse, se conserva el elemento que tenía el foco y se da el foco al botón «No»; al cerrarse, el foco vuelve al elemento conservado (por ejemplo, el botón «Eliminar» en el que se hizo clic). [untracked]: las señales leídas en esta función no se convierten en dependencias del efecto;
  • líneas 48–64: el teclado. Esc responde con «no»; Tab y Shift+Tab permanecen dentro de la ventana: desde el último botón se vuelve al primero, y viceversa. De lo contrario, el foco pasaría a la página atenuada que está detrás;
  • líneas 67–71: un clic en el fondo atenuado responde con «no».
@if (confirmation.messageKey(); as key) {
  <div (keydown)="onKeydown($event)">
    <div class="modal-backdrop fade show"></div>
    <div #dialog class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true"
         aria-labelledby="confirmation-title" aria-describedby="confirmation-message" (click)="onBackdropClick($event)">
      <div class="modal-dialog modal-dialog-centered">
        <div class="modal-content">
          <div class="modal-header">
            <h5 id="confirmation-title" class="modal-title">{{ 'CONFIRMATION.TITLE' | translate }}</h5>
            <button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate"
                    (click)="confirmation.respond(false)"></button>
          </div>
          <div class="modal-body">
            <p id="confirmation-message" class="mb-0">{{ key | translate }}</p>
          </div>
          <div class="modal-footer">
            <button #noButton type="button" class="btn btn-secondary" (click)="confirmation.respond(false)">
              {{ 'CONFIRMATION.NO' | translate }}
            </button>
            <button type="button" class="btn btn-danger" (click)="confirmation.respond(true)">{{ 'CONFIRMATION.YES' | translate }}</button>
          </div>
        </div>
      </div>
    </div>
  </div>
}
  • línea 2: se escuchan las pulsaciones de teclas en el elemento que contiene la ventana;
  • línea 14: el mensaje, una clave traducida.

10.4.8.4. src/app/components/input-field.ts

// =========================================================================
// components/input-field.ts - un campo de formulario completo
// -------------------------------------------------------------------------
// Etiqueta + campo + mensaje de ayuda O mensaje de error. Todos los
// formularios de la aplicación lo usan, con un formulario de señales:
//
//   <app-input-field [formField]="f.lastName" fieldId="lastName" label="PERSONS.LASTNAME_LABEL" [maxChars]="20" />
//
// Es un CONTROL DE FORMULARIO "CASERO": al implementar la interfaz
// FormValueControl, acepta [formField] como un <input> ordinario.
// El contrato es simple:
//   - value (un model()): el valor del campo, leído Y escrito por el
//     formulario;
//   - errors (un input opcional del contrato): si el componente
//     lo declara, la directiva [formField] coloca en él los errores del campo -
//     aquí, los devueltos por el SERVIDOR (vea pages/person-form.ts).
// label, help y el mensaje de los errores son CLAVES de traducción.
// =========================================================================

import { booleanAttribute, Component, computed, input, model } from '@angular/core';
import { FormValueControl, ValidationError } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';

@Component({
  selector: 'app-input-field',
  imports: [TranslatePipe],
  // un componente se muestra "en línea" de forma predeterminada: lo convertimos en bloque,
  // para que se apliquen las clases definidas por el padre (mb-3, col-sm-6)
  styles: `
    :host {
      display: block;
    }
  `,
  template: `
    <label class="form-label" [for]="fieldId()">{{ label() | translate }}</label>
    <input class="form-control" [id]="fieldId()" [type]="type()" [value]="value()" (input)="onInput($event)"
           [class.is-invalid]="error()" [attr.maxlength]="maxChars() ?? null" [autocomplete]="autocomplete()"
           [required]="mandatory()" [attr.aria-invalid]="error() ? 'true' : null" [attr.aria-describedby]="fieldId() + '-message'">
    @if (error(); as e) {
      <div class="invalid-feedback" [id]="fieldId() + '-message'">{{ e | translate: params() }}</div>
    } @else if (help(); as h) {
      <div class="form-text" [id]="fieldId() + '-message'">{{ h | translate: params() }}</div>
    }
  `,
})
export class InputField implements FormValueControl<string> {
  // el contrato de FormValueControl
  readonly value = model('');
  readonly errors = input<readonly ValidationError.WithOptionalFieldTree[]>([]);

  // nuestros propios inputs
  // el id del <input> (no "id": un atributo id permanecería TAMBIÉN en
  // <app-input-field>, y la página tendría dos elementos con el mismo id)
  readonly fieldId = input.required<string>();
  readonly label = input.required<string>(); // clave de traducción
  readonly type = input<'text' | 'password'>('text');
  readonly help = input<string>(); // clave del mensaje de ayuda
  readonly params = input<Record<string, string>>({}); // parámetros de los mensajes ({min}...)
  readonly maxChars = input<number>();
  readonly autocomplete = input('off');
  readonly mandatory = input(false, { transform: booleanAttribute });

  // el primer error del campo (su clave de traducción), si lo hay
  protected readonly error = computed(() => this.errors()[0]?.message);

  protected onInput(event: Event): void {
    this.value.set((event.target as HTMLInputElement).value);
  }
}

Un campo de formulario completo: etiqueta, campo, información sobre herramientas o mensaje de error. Todos los formularios de la aplicación lo utilizan. Es un control de formulario personalizado: al respetar el contrato [FormValueControl], acepta la directiva [[formField]] como si fuera un [<input>] normal:

  • línea 46: la clase implementa la interfaz [FormValueControl<string>]: el compilador verifica que cumpla con el contrato;
  • línea 48: [value], un [model()] (Ejemplo 11): el valor del campo que la directiva [[formField]] lee Y escribe;
  • línea 49: [errors], una entrada opcional del contrato: si el componente la declara, la directiva almacena allí los errores del campo;
  • líneas 54–61: entradas específicas del componente. El identificador del elemento [<input>] se llama [fieldId], y no [id]: un atributo [id] establecido en [<app-input-field>] también seguiría establecido en este elemento, y la página tendría dos elementos con el mismo identificador;
  • línea 61: [booleanAttribute] convierte la presencia del atributo ([mandatory], sin valor) en [true];
  • línea 64: el primer error del campo: su clave de traducción;
  • Líneas 36–38: el elemento [<input>] muestra el valor y lo devuelve con cada pulsación de tecla (líneas 66–68). [aria-invalid] y [aria-describedby] vinculan el campo con su mensaje para los lectores de pantalla;
  • líneas 39–43: el mensaje de error o, en su defecto, el mensaje de ayuda, traducidos junto con sus parámetros;
  • líneas 29–33: [:host] se refiere al propio elemento del componente ([<app-input-field>]). Un elemento desconocido para el navegador se muestra «en línea»: se convierte en un bloque para que surtan efecto las clases aplicadas por el padre ([col-sm-6]).

10.4.8.5. src/app/components/person-fields.ts

// =========================================================================
// components/person-fields.ts - título, nombre, apellido
// -------------------------------------------------------------------------
// Los campos de identidad, comunes a tres formularios: médico / cliente del
// ADMIN, "Create a patient account" y "Manage my account" (el equivalente del
// parcial views/partials/personFields.hbs). El padre le pasa los tres
// CAMPOS de su formulario de señales:
//     <app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />
// Un campo (FieldTree) es un valor como cualquier otro: puede pasarse
// como input de un componente, que lo enlaza a sus propios elementos HTML.
// =========================================================================

import { Component, input } from '@angular/core';
import { FieldTree, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { InputField } from './input-field';

@Component({
  selector: 'app-person-fields',
  imports: [FormField, TranslatePipe, InputField],
  template: `
    <div class="mb-3">
      <label class="form-label" for="title">{{ 'PERSONS.TITLE_LABEL' | translate }}</label>
      <!-- title(): el campo recibido como input; title()(): su estado -->
      @let titleError = title()().errors()[0]?.message;
      <select id="title" class="form-select" [formField]="title()" [class.is-invalid]="titleError">
        @for (t of TITLES; track t) {
          <option [value]="t">{{ t }}</option>
        }
      </select>
      @if (titleError) {
        <div class="invalid-feedback">{{ titleError | translate }}</div>
      }
    </div>
    <div class="row g-3 mb-3">
      <app-input-field class="col-sm-6" fieldId="firstName" label="PERSONS.FIRSTNAME_LABEL" [formField]="firstName()" [maxChars]="20" mandatory />
      <app-input-field class="col-sm-6" fieldId="lastName" label="PERSONS.LASTNAME_LABEL" [formField]="lastName()" [maxChars]="20" mandatory />
    </div>
  `,
})
export class PersonFields {
  readonly title = input.required<FieldTree<string>>();
  readonly firstName = input.required<FieldTree<string>>();
  readonly lastName = input.required<FieldTree<string>>();
  protected readonly TITLES = ['Mr', 'Mme', 'Melle'];
}

Los campos de título, nombre y apellido, comunes a tres formularios. El padre pasa a este componente los tres campos de su formulario basado en señales:

  • líneas 42–44: un campo ([FieldTree]) es un valor como cualquier otro: puede recibirse como entrada;
  • línea 25: [title()] es el campo recibido como entrada; [title()()] es su estado;
  • línea 26: la lista de títulos se vincula al campo mediante [[formField]];
  • líneas 36–37: los otros dos campos se pasan a los componentes [InputField].

10.4.8.6. src/app/components/captcha-field.ts

// =========================================================================
// components/captcha-field.ts - la imagen del captcha y el campo de entrada
// -------------------------------------------------------------------------
// Un control de formulario "casero" (FormValueControl, vea input-field.ts)
// que carga un captcha (GET /api/captcha) apenas se crea. El padre:
//   - enlaza el input a su formulario: [formField]="f.captcha";
//   - obtiene el componente mismo con viewChild(CaptchaField), para
//     llamar a sus métodos PÚBLICOS: captchaId(), y reload() después de
//     cada intento, porque una imagen puede usarse solo UNA vez (el servidor
//     la olvida en cuanto la ha verificado).
//
// [innerHTML] + bypassSecurityTrustHtml: la imagen SVG se inserta tal
// cual. Inofensivo AQUÍ porque la genera nuestro servidor
// (biblioteca svg-captcha) y no contiene nada que provenga de un
// usuario - vea el ejemplo 22.
// =========================================================================

import { Component, computed, inject, input, model, signal } from '@angular/core';
import { DomSanitizer } from '@angular/platform-browser';
import { FormValueControl, ValidationError } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../api/rdvmedecins.api';
import { Captcha } from '../api/types';

@Component({
  selector: 'app-captcha-field',
  imports: [TranslatePipe],
  styles: `
    :host {
      display: block;
    }
  `,
  template: `
    <div class="mb-3">
      <label class="form-label" for="captcha">{{ 'CAPTCHA.LABEL' | translate }}</label>
      <div class="d-flex align-items-center gap-3 mb-2">
        <div class="captcha-image" role="img" [attr.aria-label]="'CAPTCHA.IMAGE_ALT' | translate" [innerHTML]="svg()"></div>
        <a href="#" class="small" (click)="$event.preventDefault(); reload()">{{ 'CAPTCHA.NEW_IMAGE' | translate }}</a>
      </div>
      <input id="captcha" type="text" maxlength="10" autocomplete="off" autocapitalize="off" spellcheck="false"
             class="form-control" [class.is-invalid]="error()" [value]="value()" (input)="onInput($event)">
      @if (error(); as e) {
        <div class="invalid-feedback">{{ e | translate }}</div>
      } @else {
        <div class="form-text">{{ 'CAPTCHA.HELP' | translate }}</div>
      }
    </div>
  `,
})
export class CaptchaField implements FormValueControl<string> {
  readonly value = model('');
  readonly errors = input<readonly ValidationError.WithOptionalFieldTree[]>([]);

  private readonly api = inject(RdvMedecinsApi);
  private readonly sanitizer = inject(DomSanitizer);
  private readonly captcha = signal<Captcha | null>(null);
  protected readonly svg = computed(() => this.sanitizer.bypassSecurityTrustHtml(this.captcha()?.svg ?? ''));
  protected readonly error = computed(() => this.errors()[0]?.message);

  constructor() {
    this.reload();
  }

  // una nueva imagen, y un campo vacío
  async reload(): Promise<void> {
    this.value.set('');
    try {
      this.captcha.set(await this.api.captcha());
    } catch {
      this.captcha.set(null); // servidor inaccesible: el inicio de sesión fallará con un mensaje claro
    }
  }

  // el identificador de la imagen mostrada, que se enviará con la respuesta
  captchaId(): string {
    return this.captcha()?.id ?? '';
  }

  protected onInput(event: Event): void {
    this.value.set((event.target as HTMLInputElement).value);
  }
}

La imagen del CAPTCHA y su campo de entrada: otro control de formulario personalizado.

  • línea 61: se carga una imagen en cuanto se crea el componente;
  • líneas 65–72: [reload] es público: la página de inicio de sesión lo llama después de cada intento, ya que una imagen se usa una sola vez;
  • líneas 75–77: el ID de la imagen mostrada, que debe enviarse con la respuesta;
  • línea 37: la imagen SVG (ejemplo 22), con texto alternativo para los lectores de pantalla;
  • línea 40: [autocapitalize] y [spellcheck]: sin mayúsculas automáticas ni corrección ortográfica en un teléfono.

La página padre obtiene este componente mediante [viewChild(CaptchaField)] (ejemplo 13) para llamar a sus métodos públicos.

10.4.8.7. src/app/components/booking-dialog

// =========================================================================
// components/booking-dialog/booking-dialog.ts
// -------------------------------------------------------------------------
// El diálogo para reservar un horario. El mismo diálogo que
// views/partials/booking.hbs de la aplicación HTML: las clases de Bootstrap
// de un diálogo modal, mostrado "fijo en el código" (show d-block).
//
// El componente no habla con el servidor: emite
//   - confirm, con el paciente elegido (null para un paciente que reserva
//     para sí mismo);
//   - close.
// Es la página de la agenda la que decide qué hacer con ello (pages/schedule.ts).
// =========================================================================

import { afterNextRender, Component, ElementRef, input, output, signal, viewChild } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { TranslatePipe } from '@ngx-translate/core';
import { Person } from '../../api/types';
import { LabelPipe } from '../../pipes/formatting.pipes';

@Component({
  selector: 'app-booking-dialog',
  imports: [FormsModule, TranslatePipe, LabelPipe],
  // Escape, en cualquier parte de la página: se cierra
  host: { '(document:keydown.escape)': 'close.emit()' },
  templateUrl: './booking-dialog.html',
})
export class BookingDialog {
  readonly time = input.required<string>(); // "8:00 - 8:20"
  readonly clients = input<readonly Person[]>([]); // ADMIN / DOCTOR: los pacientes entre los que elegir
  readonly patient = input<string | null>(null); // USER: el paciente es él mismo
  readonly submitting = input(false);

  readonly confirm = output<number | null>();
  readonly close = output<void>();

  protected readonly clientId = signal<number | null>(null);
  private readonly list = viewChild<ElementRef<HTMLSelectElement>>('list');
  private readonly confirmButton = viewChild.required<ElementRef<HTMLButtonElement>>('confirmButton');

  constructor() {
    // al mostrarse, el foco va al primer elemento útil del diálogo
    afterNextRender(() => (this.list() ?? this.confirmButton()).nativeElement.focus());
  }

  // un clic en el fondo atenuado (y no en el diálogo mismo) cierra el diálogo
  protected onBackdropClick(e: MouseEvent): void {
    if (e.target === e.currentTarget) {
      this.close.emit();
    }
  }
}

La ventana de reserva de horarios. No se comunica con el servidor: recibe lo que muestra y envía la decisión del usuario; es la página del calendario la que realiza la acción.

  • Líneas 29–32: entradas: el horario, los pacientes entre los que elegir (ADMIN, DOCTOR) o el propio paciente (USER), y un indicador de «envío»;
  • Líneas 34–35: salidas: confirmar, con el paciente seleccionado; cerrar;
  • línea 25: Esc cierra la ventana;
  • línea 43: [afterNextRender] (ejemplo 13): una vez que se muestra la ventana, el foco pasa a la lista de pacientes o, en su defecto, al botón de confirmación.
<div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true" aria-labelledby="booking-title"
     (click)="onBackdropClick($event)">
  <div class="modal-dialog modal-dialog-centered">
    <form class="modal-content" (ngSubmit)="confirm.emit(clientId())">
      <div class="modal-header">
        <h5 id="booking-title" class="modal-title">{{ 'BOOKING_DIALOG.TITLE' | translate }}</h5>
        <button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate"
                (click)="close.emit()"></button>
      </div>

      <div class="modal-body">
        <p>{{ 'BOOKING_DIALOG.SLOT' | translate: { time: time() } }}</p>
        <!-- un paciente reserva para sí mismo: sin lista (y el servidor
             ignoraría de todos modos un posible clientId) -->
        @if (patient() !== null) {
          <p class="mb-0">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}: <strong>{{ patient() }}</strong></p>
        } @else {
          <label class="form-label" for="clientId">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}</label>
          <select #list id="clientId" name="clientId" class="form-select" [(ngModel)]="clientId">
            <option [ngValue]="null">{{ 'BOOKING_DIALOG.CHOOSE_PATIENT' | translate }}</option>
            @for (c of clients(); track c.id) {
              <option [ngValue]="c.id">{{ c | label }}</option>
            }
          </select>
        }
      </div>

      <div class="modal-footer">
        <button type="button" class="btn btn-secondary" (click)="close.emit()">{{ 'BOOKING_DIALOG.CANCEL' | translate }}</button>
        <button #confirmButton type="submit" class="btn btn-primary" [disabled]="submitting()">
          {{ 'BOOKING_DIALOG.CONFIRM' | translate }}
        </button>
      </div>
    </form>
  </div>
</div>
  • línea 5: un formulario: la tecla Enter confirma;
  • líneas 16–26: un paciente hace una reserva para sí mismo: sin lista;
  • líneas 21–24: [[ngValue]] (ejemplo 05): el valor de cada opción es un número o [null];
  • línea 31: el botón está deshabilitado durante el envío: no hay doble reserva por doble clic.

10.4.9. Las páginas

10.4.9.1. src/app/pages/login

// =========================================================================
// pages/login/login.ts - la página de inicio de sesión (/login)
// -------------------------------------------------------------------------
// La misma página que views/login.hbs de la aplicación HTML: login, contraseña,
// captcha, y un segundo botón "Create a patient account" que verifica el
// MISMO captcha antes de abrir la creación de la cuenta.
//
// /login?login=jbernard: el campo login se rellena previamente (justo después de la
// creación de una cuenta).
// /login?redirect=/doctors: tras iniciar sesión, se abre esta página
// (colocada allí por el guardia del enrutador) en lugar de la página de inicio del rol.
// Estos dos parámetros llegan como INPUTS del componente.
// =========================================================================

import { afterNextRender, Component, inject, input, signal, viewChild } from '@angular/core';
import { Router } from '@angular/router';
import { form, FormField, required } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { CaptchaField } from '../../components/captcha-field';

@Component({
  selector: 'app-login',
  imports: [FormField, TranslatePipe, CaptchaField],
  templateUrl: './login.html',
})
export class LoginPage {
  readonly login = input<string>(); // ?login=...
  readonly redirect = input<string>(); // ?redirect=...

  private readonly api = inject(RdvMedecinsApi);
  private readonly session = inject(SessionService);
  private readonly messages = inject(MessagesService);
  private readonly router = inject(Router);

  protected readonly model = signal({ login: '', password: '', captcha: '' });
  // dos reglas: login y contraseña obligatorios. [formField] establece entonces
  // el atributo HTML required en ambos campos, y el navegador rechaza
  // enviar el formulario mientras estén vacíos
  protected readonly f = form(this.model, (p) => {
    required(p.login);
    required(p.password);
  });
  private readonly submission = new FormSubmission(this.f);
  // el componente captcha, para llamar a sus métodos captchaId() y reload()
  private readonly captchaField = viewChild.required(CaptchaField);

  constructor() {
    afterNextRender(() => {
      // los inputs ya se conocen: el login de la URL, si lo hay
      const login = (this.login() ?? '').slice(0, 30);
      this.model.update((m) => ({ ...m, login }));
      // el foco: en la contraseña si el login ya está rellenado
      (login ? this.f.password : this.f.login)().focusBoundControl();
    });
  }

  // ambos botones comparten este flujo: envío y, en caso de fallo,
  // mensaje de error y NUEVA imagen (cada una puede usarse solo una vez)
  private async attempt(action: () => Promise<unknown>, ignoreValidators = false): Promise<void> {
    this.messages.clear();
    await this.submission.submit(async () => {
      try {
        await action();
      } catch (e) {
        // la nueva imagen ANTES de asociar el error al campo:
        // reload() vacía el campo, lo que borraría el error
        await this.captchaField().reload();
        throw e;
      }
    }, ignoreValidators);
  }

  protected async logIn(event: Event): Promise<void> {
    event.preventDefault();
    const { login, password, captcha } = this.model();
    await this.attempt(async () => {
      await this.session.logIn(login.trim(), password, this.captchaField().captchaId(), captcha);
      const redirect = this.redirect();
      // solo una ruta INTERNA: nunca una redirección a otro sitio
      const internal = redirect !== undefined && redirect.startsWith('/') && !redirect.startsWith('//');
      await this.router.navigateByUrl(internal ? redirect : this.session.homePage());
    });
  }

  protected async createAccount(): Promise<void> {
    await this.attempt(async () => {
      await this.api.registrationAccess(this.captchaField().captchaId(), this.model().captcha);
      await this.router.navigate(['/register']);
    }, true); // login y contraseña no se usan aquí: sus reglas se ignoran
  }
}

La página de inicio de sesión: nombre de usuario, contraseña, CAPTCHA y un segundo botón «Crear una cuenta de paciente» que verifica el MISMO CAPTCHA antes de permitir la creación de la cuenta.

  • Líneas 31–32: dos parámetros de URL: /login?login=jbernard rellena previamente el nombre de usuario (inmediatamente después de crear la cuenta); /login?redirect=/doctors, establecido por la guardia, indica la página que se abrirá tras iniciar sesión;
  • Líneas 43–46: el único formulario de la aplicación con un esquema: el nombre de usuario y la contraseña son obligatorios. La directiva [[formField]] establece entonces el atributo HTML [required] en ambos campos, y el navegador se niega a enviar el formulario mientras estén vacíos;
  • línea 47: el envío del formulario (services/form-submission.ts);
  • línea 49: el componente captcha, para llamar a sus métodos;
  • líneas 52–58: [afterNextRender]: una vez que se muestra la página, se conocen las entradas. El nombre de usuario de la URL se copia en el formulario (limitado a 30 caracteres) y se da el foco al primer campo vacío. [focusBoundControl()] da el foco al elemento vinculado al campo mediante [[formField]];
  • Líneas 63–75: ambos botones siguen esta secuencia: enviar y, si falla, una nueva imagen (cada una se usa una sola vez). El orden importa: [reload] borra el campo del CAPTCHA, lo que eliminaría el error asociado a ese campo; por eso recargamos la imagen ANTES, para volver a provocar el error, que [FormSubmission] asociará entonces al campo;
  • líneas 77–87: inicio de sesión, seguido de la navegación a la página solicitada o a la página de inicio del rol. Como en el Ejemplo 18, solo se acepta una ruta interna (línea 84);
  • líneas 89–94: el segundo botón. El servidor verifica el CAPTCHA y establece un «pase» (una cookie); entonces se abre la página de creación de cuenta. El nombre de usuario y la contraseña no se usan aquí: se ignoran las reglas del esquema (línea 93).
<div class="row justify-content-center">
  <div class="col-sm-8 col-md-6 col-lg-5">
    <div class="card p-4">
      <h5 class="card-title mb-3">{{ 'LOGIN.TITLE' | translate }}</h5>

      <form (submit)="logIn($event)">
        <div class="mb-3">
          <label class="form-label" for="login">{{ 'LOGIN.LOGIN_LABEL' | translate }}</label>
          <input id="login" type="text" class="form-control" autocomplete="username" [formField]="f.login">
        </div>
        <div class="mb-3">
          <label class="form-label" for="password">{{ 'LOGIN.PASSWORD_LABEL' | translate }}</label>
          <input id="password" type="password" class="form-control" autocomplete="current-password"
                 [formField]="f.password">
        </div>

        <!-- un control "casero", enlazado al campo captcha del formulario -->
        <app-captcha-field [formField]="f.captcha" />

        <!-- type="submit": Enter en un campo activa "Log in" -->
        <button type="submit" class="btn btn-primary w-100" [disabled]="f().submitting()">{{ 'LOGIN.SUBMIT' | translate }}</button>

        <!-- type="button": este botón no envía el formulario (sin verificación
             required de login y password, inútil aquí) -->
        <button type="button" class="btn btn-outline-primary w-100 mt-3" [disabled]="f().submitting()" (click)="createAccount()">
          {{ 'LOGIN.CREATE_ACCOUNT' | translate }}
        </button>
        <div class="form-text text-center">{{ 'LOGIN.CREATE_ACCOUNT_HELP' | translate }}</div>
      </form>

      <div class="text-muted small mt-3">
        {{ 'LOGIN.DEMO_ACCOUNTS' | translate }}
        <ul class="mb-0 mt-1">
          <li><code>admin</code> - {{ 'LOGIN.DEMO_ADMIN' | translate }}</li>
          <li><code>pelissier</code>, <code>tatou</code>, <code>dupont</code> - {{ 'LOGIN.DEMO_DOCTOR' | translate }}</li>
          <li><code>martin</code>, <code>durand</code>, <code>bistrou</code>, <code>german</code> - {{ 'LOGIN.DEMO_USER' | translate }}</li>
        </ul>
      </div>
    </div>
  </div>
</div>
  • línea 6: aquí no hay [novalidate] : el navegador informa de un nombre de usuario o una contraseña vacíos;
  • línea 18: el control personalizado del CAPTCHA, vinculado al campo [captcha] del formulario;
  • línea 21: el botón está deshabilitado durante el envío ([submitting()]);
  • línea 25: [type="button"]: este botón no envía el formulario, por lo que el navegador no exige un nombre de usuario ni una contraseña.

10.4.9.2. src/app/pages/schedule

// =========================================================================
// pages/schedule/schedule.ts - la página de la agenda (/schedule)
// -------------------------------------------------------------------------
// Tres bloques, como views/schedule.hbs de la aplicación HTML:
//   1. la elección del médico y del día;
//   2. la agenda de ese médico en ese día;
//   3. el diálogo para reservar un horario.
//
// Como en la aplicación HTML, TODO el estado de la página está en su URL:
//     /schedule?doctorId=1&day=2026-10-05           la agenda
//     /schedule?doctorId=1&day=2026-10-05&book=7    + el diálogo de reserva
// Por lo tanto, la página puede recargarse, guardarse como marcador, y los botones
// Atrás / Adelante del navegador funcionan. La página SIGUE su URL: los tres
// parámetros llegan como INPUTS (señales), y un efecto vuelve a cargar
// la agenda cuando cambia el médico o el día; las acciones del
// usuario, por su parte, cambian la URL (router.navigate).
//
// Lo que cada uno ve y puede hacer lo decide el SERVIDOR (campos
// patient, mine, bookable, appointmentId de cada horario): la página se limita
// a mostrarlo. Un paciente ni siquiera recibe el nombre de los demás pacientes.
// =========================================================================

import { Component, computed, effect, inject, input, signal, untracked } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { FormsModule } from '@angular/forms';
import { TranslatePipe } from '@ngx-translate/core';
import { ApiError } from '../../api/api-error';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { Schedule, ScheduleSlot, Person } from '../../api/types';
import { today, isValidDate, timeRange } from '../../pipes/formatting';
import { TimeRangePipe, LongDatePipe, LabelPipe } from '../../pipes/formatting.pipes';
import { LanguageService } from '../../i18n/language.service';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { BookingDialog } from '../../components/booking-dialog/booking-dialog';

// "3" -> 3; "", "abc", "-2", ausente -> null
function positiveInteger(value: string | undefined): number | null {
  const n = Number(value);
  return value !== undefined && value !== '' && Number.isInteger(n) && n > 0 ? n : null;
}

@Component({
  selector: 'app-schedule',
  imports: [FormsModule, RouterLink, TranslatePipe, TimeRangePipe, LongDatePipe, LabelPipe, BookingDialog],
  templateUrl: './schedule.html',
})
export class SchedulePage {
  // los parámetros de la URL (undefined si están ausentes)
  readonly doctorId = input<string>();
  readonly day = input<string>();
  readonly book = input<string>();

  private readonly api = inject(RdvMedecinsApi);
  private readonly router = inject(Router);
  protected readonly session = inject(SessionService);
  private readonly messages = inject(MessagesService);
  private readonly confirmation = inject(ConfirmationService);
  protected readonly language = inject(LanguageService).language;

  protected readonly doctors = signal<Person[]>([]);
  protected readonly clients = signal<Person[]>([]); // ADMIN / DOCTOR: para el diálogo de reserva
  protected readonly schedule = signal<Schedule | null>(null);
  protected readonly loading = signal(false);
  protected readonly submitting = signal(false);

  // los valores del formulario "médico + día", copiados de la URL
  protected readonly doctorChoice = signal<number | null>(null);
  protected readonly dayChoice = signal(today());

  // la agenda mostrada, sin diálogo de reserva: la consulta "de vuelta"
  protected readonly scheduleQuery = computed(() => ({ doctorId: String(this.doctorChoice() ?? ''), day: this.dayChoice() }));

  // el horario cuyo diálogo de reserva está abierto (?book=7),
  // solo si este usuario puede reservarlo
  protected readonly slotToBook = computed<ScheduleSlot | null>(() => {
    const id = positiveInteger(this.book());
    return this.schedule()?.slots.find((c) => c.id === id && c.bookable) ?? null;
  });

  // el nombre del paciente con sesión iniciada (USER), o null para ADMIN y DOCTOR
  protected readonly patient = computed(() => (this.session.isPatient() ? (this.session.user()?.name ?? '') : null));

  constructor() {
    this.loadLists();
    // la agenda sigue la URL (médico y día): el efecto LEE ambos inputs,
    // y la carga se hace sin seguimiento (untracked)
    effect(() => {
      const doctorId = this.doctorId();
      const day = this.day();
      untracked(() => this.loadSchedule(doctorId, day));
    });
  }

  // -------------------------------------------------------------------------
  // cargando
  // -------------------------------------------------------------------------
  private async loadLists(): Promise<void> {
    try {
      this.doctors.set(await this.api.list('doctors'));
      // la lista de pacientes: solo para quienes tienen permiso de leerla
      if (this.session.isManager()) {
        this.clients.set(await this.api.list('clients'));
      }
    } catch (e) {
      this.messages.showApiError(e);
    }
  }

  private async loadSchedule(urlDoctorId: string | undefined, urlDay: string | undefined): Promise<void> {
    // el día: el de la URL si es válido; de lo contrario, hoy
    this.dayChoice.set(today());
    if (urlDay !== undefined) {
      if (!isValidDate(urlDay)) {
        this.schedule.set(null);
        this.messages.showError('ERRORS.INVALID_DATE');
        return;
      }
      this.dayChoice.set(urlDay);
    }
    // el médico: el de la URL; sin médico, un DOCTOR ve SU agenda
    // (el servidor la encuentra a partir del token)
    const doctorId = positiveInteger(urlDoctorId);
    this.doctorChoice.set(doctorId);
    if (doctorId === null && this.session.role() !== 'DOCTOR') {
      this.schedule.set(null);
      return;
    }
    this.loading.set(true);
    try {
      const schedule = await this.api.schedule(doctorId, this.dayChoice());
      this.schedule.set(schedule);
      this.doctorChoice.set(schedule.doctor.id);
    } catch (e) {
      this.schedule.set(null);
      this.messages.showApiError(e);
    } finally {
      this.loading.set(false);
    }
  }

  // la agenda de la URL actual, leída de nuevo (después de una reserva o una cancelación)
  private reload(): Promise<void> {
    return this.loadSchedule(this.doctorId(), this.day());
  }

  // -------------------------------------------------------------------------
  // acciones
  // -------------------------------------------------------------------------

  // "View schedule": se cambia la URL, la agenda la sigue (efecto de arriba)
  protected viewSchedule(): void {
    this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
  }

  protected closeBooking(): void {
    this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
  }

  protected async confirmBooking(clientId: number | null): Promise<void> {
    const slot = this.slotToBook();
    if (slot === null) {
      return;
    }
    this.submitting.set(true);
    try {
      await this.api.book(this.dayChoice(), slot.id, this.session.isManager() ? clientId : null);
      this.messages.flash('success', 'SCHEDULE.BOOKED');
    } catch (e) {
      if (e instanceof ApiError && e.key === 'ERRORS.CHOOSE_PATIENT') {
        // ningún paciente elegido: el diálogo permanece abierto
        this.messages.showError(e.key);
        return; // (finally se ejecuta de todos modos)
      }
      if (!(e instanceof ApiError)) {
        throw e;
      }
      // horario ocupado entretanto, paciente que ya tiene una cita...:
      // el mensaje se mostrará en la agenda, con el diálogo cerrado
      this.messages.flash('error', e.key, e.params);
    } finally {
      this.submitting.set(false);
    }
    await this.router.navigate(['/schedule'], { queryParams: this.scheduleQuery() });
    await this.reload(); // el servidor es la referencia: la agenda se lee de nuevo
  }

  protected async cancel(c: ScheduleSlot): Promise<void> {
    if (c.appointmentId === null || !(await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM'))) {
      return;
    }
    try {
      await this.api.cancelAppointment(c.appointmentId);
      this.messages.showSuccess('SCHEDULE.CANCELLED');
    } catch (e) {
      this.messages.showApiError(e);
    }
    await this.reload();
  }

  protected timeRange(c: ScheduleSlot): string {
    return timeRange(c);
  }
}

La página con más funcionalidades de la aplicación. Como en la aplicación HTML, TODO el estado de la página está incluido en su URL: /schedule?doctorId=1&day=2026-10-05 muestra un calendario, y &book=7 agrega la ventana de reserva. Por lo tanto, se puede recargar la página, guardarla como marcador y usar los botones Atrás/Adelante. El principio: la página sigue a su URL, y las acciones del usuario modifican la URL.

  • líneas 51–53: los tres parámetros de la URL, como entradas;
  • líneas 39–42: un parámetro de dirección puede contener cualquier cosa; se valida;
  • líneas 69–70: los valores del formulario «médico + día», copiados de la URL;
  • línea 73: los parámetros del calendario mostrado, sin ventana de reserva;
  • líneas 77–80: el horario para el que está abierta la ventana de reserva, calculado a partir de la dirección ([?book=7]) y del calendario: solo si este usuario puede reservarlo. Un [computed]: cuando cambia la dirección, la ventana se abre o se cierra automáticamente;
  • líneas 89–93: un efecto que depende de las dos entradas [doctorId] y [day]: el calendario se recarga cuando cualquiera de ellas cambia. La recarga se realiza en [untracked]: las señales que lee y modifica no se convierten en dependencias del efecto. La entrada [book] no se lee: abrir o cerrar la ventana no recarga el calendario;
  • líneas 99–109: los médicos y los pacientes, para quienes tienen permiso para verlos;
  • líneas 111–141: la carga del calendario. Se informa de una fecha no válida (líneas 115–118); sin médico, un DOCTOR ve SU PROPIO calendario: el servidor lo obtiene a partir del token (líneas 126–129);
  • líneas 153–159: «Ver agenda» y el cierre de la ventana modifican la dirección; el calendario la sigue;
  • líneas 161–187: la reserva de la cita. Si tiene éxito, se prepara un mensaje flash (línea 169); se mostrará después de la línea 185, que cierra la ventana. Si no se ha seleccionado ningún paciente, la ventana permanece abierta (líneas 171–175). Cualquier otro error (horario tomado entretanto, etc.) se mostrará en el calendario, con la ventana cerrada. En todos los casos, se vuelve a leer el calendario: el registro del servidor es definitivo (línea 186);
  • líneas 189–200: la cancelación, tras la confirmación.
<!-- 1. la elección del médico y del día -->
<form class="card p-3 mb-3" (ngSubmit)="viewSchedule()">
  <div class="row g-2 align-items-end">
    <div class="col-sm-5">
      <label class="form-label" for="doctorId">{{ 'DOCTOR_DAY_PICKER.DOCTOR_LABEL' | translate }}</label>
      <select id="doctorId" name="doctorId" class="form-select" required [(ngModel)]="doctorChoice">
        <option [ngValue]="null">{{ 'DOCTOR_DAY_PICKER.CHOOSE_DOCTOR' | translate }}</option>
        @for (d of doctors(); track d.id) {
          <option [ngValue]="d.id">{{ d | label }}</option>
        }
      </select>
    </div>
    <div class="col-sm-4">
      <label class="form-label" for="day">{{ 'DOCTOR_DAY_PICKER.DAY_LABEL' | translate }}</label>
      <input id="day" name="day" type="date" class="form-control" required [(ngModel)]="dayChoice">
    </div>
    <div class="col-sm-3">
      <button type="submit" class="btn btn-primary w-100">{{ 'DOCTOR_DAY_PICKER.VIEW_SCHEDULE' | translate }}</button>
    </div>
  </div>
</form>

@let s = schedule();

<!-- paciente que ya tiene una cita próxima: por eso no hay botón "Book" -->
@if (s?.info; as info) {
  <div class="alert alert-info">
    {{ info | translate }} <a routerLink="/my-area" class="alert-link">{{ 'APP.MENU_MY_AREA' | translate }}</a>
  </div>
}

<!-- 2. la agenda -->
@if (loading() && !s) {
  <p class="text-muted">{{ 'APP.LOADING' | translate }}</p>
} @else if (s) {
  <div class="card p-3">
    <h5>{{ 'SCHEDULE.TITLE_PREFIX' | translate }} {{ s.day | longDate: language() }} - {{ s.doctor | label }}</h5>
    @if (s.slots.length > 0) {
      <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 (c of s.slots; track c.id) {
            <tr [class.free-slot]="c.bookable">
              <td>{{ c | timeRange }}</td>
              <td>
                @if (c.free) {
                  <span class="badge text-bg-success">{{ 'SCHEDULE.FREE' | translate }}</span>
                } @else if (c.patient; as p) {
                  <span class="badge" [class]="c.mine ? 'text-bg-primary' : 'text-bg-secondary'">{{ p | label }}</span>
                } @else {
                  <span class="badge text-bg-secondary">{{ 'SCHEDULE.BOOKED_BY_OTHER' | translate }}</span>
                }
              </td>
              <td class="text-end">
                <!-- "Book" es un ENLACE: agrega &book=... a la URL, lo que
                     abre el diálogo de reserva -->
                @if (c.bookable) {
                  <a class="btn btn-sm btn-outline-success" routerLink="/schedule" [queryParams]="{ doctorId: scheduleQuery().doctorId, day: scheduleQuery().day, book: c.id }">
                    {{ 'SCHEDULE.BOOK' | translate }}
                  </a>
                }
                @if (c.appointmentId !== null) {
                  <button type="button" class="btn btn-sm btn-outline-danger" (click)="cancel(c)">
                    {{ 'SCHEDULE.CANCEL_APPOINTMENT' | translate }}
                  </button>
                }
              </td>
            </tr>
          }
        </tbody>
      </table>
    } @else {
      <p class="text-muted mb-0">{{ 'SCHEDULE.NO_SLOTS' | translate }}</p>
    }
  </div>
} @else {
  <p class="text-muted">{{ 'SCHEDULE.EMPTY_STATE' | translate }}</p>
}

<!-- 3. el diálogo de reserva, solo si la URL contiene &book=... -->
@if (slotToBook(); as c) {
  <app-booking-dialog [time]="timeRange(c)" [clients]="clients()" [patient]="patient()"
                           [submitting]="submitting()" (confirm)="confirmBooking($event)"
                           (close)="closeBooking()" />
}
  • líneas 2–21: selección del médico y del día, con [ngModel] (ejemplo 05);
  • línea 23: [@let]: el calendario, leído una sola vez;
  • líneas 26–30: un paciente que ya tiene una cita próxima: el servidor envía un mensaje que explica por qué no hay botón «Reservar»;
  • línea 37: la fecha escrita completa, en el idioma local;
  • líneas 52–58: el estado del horario: disponible, el paciente (mostrado en azul) o «Reservado» cuando el servidor no envió el nombre del paciente;
  • líneas 63–67: «Reservar» es un enlace: agrega &book=... a la URL, lo que abre la ventana de reserva;
  • líneas 87–91: la ventana de reserva, solo si la URL contiene &book=... y el horario es reservable.

10.4.9.3. src/app/pages/persons/persons.config.ts

// =========================================================================
// pages/persons/persons.config.ts - ¿médicos o clientes?
// -------------------------------------------------------------------------
// Las páginas que gestionan los médicos y los clientes son IDÉNTICAS: la misma
// lista, el mismo formulario. Como en la aplicación HTML (clase abstracta
// PersonsController), se escriben UNA sola vez (persons.ts,
// person-form.ts); solo cambian la dirección de la API y las claves de las
// etiquetas, descritas aquí. El enrutador da el tipo en los
// datos de cada ruta (vea app.routes.ts).
// =========================================================================

import { PersonType } from '../../api/rdvmedecins.api';

export interface PersonKeys {
  title: string; // "Doctors"
  add: string; // "Add a doctor"
  edit: string; // "Edit a doctor"
  empty: string; // "No doctor."
  confirmDelete: string;
  added: string; // "Doctor {{name}} has been added (login: {{login}})."
  edited: string;
  deleted: string;
}

export const PERSON_KEYS: Record<PersonType, PersonKeys> = {
  doctors: {
    title: 'DOCTORS.TITLE',
    add: 'DOCTORS.ADD',
    edit: 'DOCTORS.EDIT',
    empty: 'DOCTORS.EMPTY',
    confirmDelete: 'DOCTORS.DELETE_CONFIRM',
    added: 'DOCTORS.ADDED',
    edited: 'DOCTORS.UPDATED',
    deleted: 'DOCTORS.DELETED',
  },
  clients: {
    title: 'CLIENTS.TITLE',
    add: 'CLIENTS.ADD',
    edit: 'CLIENTS.EDIT',
    empty: 'CLIENTS.EMPTY',
    confirmDelete: 'CLIENTS.DELETE_CONFIRM',
    added: 'CLIENTS.ADDED',
    edited: 'CLIENTS.UPDATED',
    deleted: 'CLIENTS.DELETED',
  },
};

// {{name}} y {{login}} de los mensajes "added / updated / deleted"
export function messageParams(p: { firstName: string; lastName: string; login?: string }): Record<string, string> {
  return { name: `${p.firstName} ${p.lastName}`, login: p.login ?? '' };
}

Las páginas de gestión de médicos y de clientes son idénticas: la misma lista, el mismo formulario. Como en la aplicación HTML (clase abstracta [PersonsController]), se escriben una sola vez; lo único que cambia es la dirección de la API y las claves de las etiquetas, que se describen aquí:

  • línea 25: [Record<PersonType, PersonKeys>]: el compilador exige exactamente una entrada por cada tipo, ni más ni menos;
  • líneas 49–51: los parámetros de los mensajes «agregado / modificado / eliminado».

10.4.9.4. src/app/pages/persons

// =========================================================================
// pages/persons/persons.ts - la lista de médicos O de clientes (ADMIN)
// -------------------------------------------------------------------------
// Una sola página para ambos: el tipo ('doctors' o 'clients') está en
// los datos de la ruta (data.type, vea app.routes.ts) y llega como
// INPUT del componente; las etiquetas específicas de cada uno están en
// persons.config.ts. Equivalente de views/persons/list.hbs de
// la aplicación HTML.
// "export default": la ruta carga la página bajo demanda (loadComponent).
// =========================================================================

import { Component, computed, inject, input, OnInit, signal } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi, PersonType } from '../../api/rdvmedecins.api';
import { Person } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { PERSON_KEYS, messageParams } from './persons.config';

@Component({
  selector: 'app-persons',
  imports: [RouterLink, TranslatePipe],
  templateUrl: './persons.html',
})
export default class PersonsPage implements OnInit {
  readonly type = input.required<PersonType>(); // data.type de la ruta

  private readonly api = inject(RdvMedecinsApi);
  private readonly messages = inject(MessagesService);
  private readonly confirmation = inject(ConfirmationService);

  protected readonly keys = computed(() => PERSON_KEYS[this.type()]);
  protected readonly persons = signal<Person[] | null>(null); // null: aún no cargado

  // ngOnInit en lugar del constructor: los inputs (type) ya se conocen
  ngOnInit(): void {
    this.load();
  }

  private async load(): Promise<void> {
    try {
      this.persons.set(await this.api.list(this.type()));
    } catch (e) {
      this.messages.showApiError(e);
    }
  }

  protected async remove(p: Person): Promise<void> {
    if (!(await this.confirmation.confirm(this.keys().confirmDelete))) {
      return;
    }
    try {
      await this.api.remove(this.type(), p.id);
      this.messages.showSuccess(this.keys().deleted, messageParams(p));
    } catch (e) {
      // un médico que aún tiene citas: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
      this.messages.showApiError(e);
    }
    await this.load();
  }
}
  • línea 26: [export default]: la ruta carga la página bajo demanda (ejemplo 17);
  • línea 27: el tipo (['doctors'] o ['clients']) proviene de los datos de entrada de la ruta;
  • línea 33: las claves de las etiquetas de este tipo;
  • línea 34: [null]: la lista aún no se ha cargado;
  • Líneas 37–39: [ngOnInit] (Ejemplo 13) en lugar del constructor: así las entradas ya son conocidas;
  • líneas 49–61: eliminación, tras la confirmación. Un médico que todavía tiene citas no puede eliminarse: el servidor devuelve una respuesta 409 y se muestra su mensaje.
<div class="d-flex justify-content-between align-items-center mb-3">
  <h4 class="mb-0">{{ keys().title | translate }}</h4>
  <a class="btn btn-primary" [routerLink]="['/', type(), 'add']">{{ keys().add | translate }}</a>
</div>

<div class="card p-3">
  @let list = persons();
  @if (list === null) {
    <p class="text-muted mb-0">{{ 'APP.LOADING' | translate }}</p>
  } @else if (list.length === 0) {
    <p class="text-muted mb-0">{{ keys().empty | translate }}</p>
  } @else {
    <table class="table table-hover align-middle mb-0">
      <thead>
        <tr>
          <th>{{ 'PERSONS.COLUMN_TITLE' | translate }}</th>
          <th>{{ 'PERSONS.COLUMN_FIRSTNAME' | translate }}</th>
          <th>{{ 'PERSONS.COLUMN_LASTNAME' | translate }}</th>
          <th>{{ 'PERSONS.COLUMN_LOGIN' | translate }}</th>
          <th></th>
        </tr>
      </thead>
      <tbody>
        @for (p of list; track p.id) {
          <tr>
            <td>{{ p.title }}</td>
            <td>{{ p.firstName }}</td>
            <td>{{ p.lastName }}</td>
            <td><code>{{ p.login }}</code></td>
            <td class="text-end">
              <div class="d-inline-flex gap-2">
                <a class="btn btn-sm btn-outline-primary" [routerLink]="['/', type(), p.id, 'edit']">{{ 'PERSONS.EDIT' | translate }}</a>
                <button type="button" class="btn btn-sm btn-outline-danger" (click)="remove(p)">{{ 'PERSONS.DELETE' | translate }}</button>
              </div>
            </td>
          </tr>
        }
      </tbody>
    </table>
  }
</div>
  • línea 3: [['/', type(), 'add']]: /doctors/add o /clients/add;
  • líneas 8–12: durante la carga, una lista vacía, una lista;
  • línea 32: /doctors/3/edit.

10.4.9.5. src/app/pages/person-form

// =========================================================================
// pages/person-form/person-form.ts - creación O actualización
// de un médico o de un cliente (ADMIN)
// -------------------------------------------------------------------------
//     /doctors/add               -> creación (sin input id)
//     /doctors/3/edit            -> actualización (input id = 3)
// (y las mismas direcciones bajo /clients). Equivalente de
// views/persons/form.hbs de la aplicación HTML.
//
// Aquí no se verifica ninguna regla: el servidor valida todo, y sus errores
// se muestran bajo los campos (vea services/form-submission.ts).
// La VERSIÓN leída con el registro regresa con la actualización: si otro
// ADMIN lo ha actualizado entretanto, el servidor responde 409 CONCURRENT_UPDATE.
// =========================================================================

import { Component, computed, inject, input, numberAttribute, OnInit, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { ApiError } from '../../api/api-error';
import { RdvMedecinsApi, PersonType } from '../../api/rdvmedecins.api';
import { PersonData } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';
import { PERSON_KEYS, messageParams } from '../persons/persons.config';

@Component({
  selector: 'app-person-form',
  imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
  templateUrl: './person-form.html',
})
export default class PersonFormPage implements OnInit {
  readonly type = input.required<PersonType>(); // data.type de la ruta
  // el parámetro :id de la dirección, convertido a número; ausente en una creación
  readonly id = input(undefined, { transform: (v: string | undefined) => (v === undefined ? undefined : numberAttribute(v)) });

  private readonly api = inject(RdvMedecinsApi);
  private readonly messages = inject(MessagesService);
  private readonly router = inject(Router);

  protected readonly keys = computed(() => PERSON_KEYS[this.type()]);
  protected readonly creating = computed(() => this.id() === undefined);

  protected readonly model = signal<PersonData>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', version: undefined });
  protected readonly f = form(this.model); // sin validador: el servidor valida
  protected readonly submission = new FormSubmission(this.f);

  // actualización: se lee el registro (incluida su versión)
  async ngOnInit(): Promise<void> {
    const id = this.id();
    if (id === undefined) {
      return;
    }
    try {
      const p = await this.api.read(this.type(), id);
      this.model.set({ title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', password: '', version: p.version });
    } catch (e) {
      // registro que no existe (eliminado entretanto...): de vuelta a la lista
      if (!(e instanceof ApiError)) {
        throw e;
      }
      this.messages.flash('error', e.key, e.params);
      this.router.navigate(['/', this.type()]);
    }
  }

  protected async save(event: Event): Promise<void> {
    event.preventDefault();
    const id = this.id();
    const succeeded = await this.submission.submit(async () => {
      const data = this.model();
      const p = id === undefined ? await this.api.add(this.type(), data) : await this.api.edit(this.type(), id, data);
      this.messages.flash('success', this.creating() ? this.keys().added : this.keys().edited, messageParams(p));
    });
    const key = this.messages.error()?.key;
    if (succeeded) {
      this.router.navigate(['/', this.type()]);
    } else if (key === 'ERRORS.DOCTOR_NOT_FOUND' || key === 'ERRORS.PATIENT_NOT_FOUND') {
      // eliminado entretanto por otro ADMIN: de vuelta a la lista
      this.messages.flash('error', key);
      this.router.navigate(['/', this.type()]);
    }
  }
}

Creación (/doctors/add) O modificación (/doctors/3/edit) de un médico o de un cliente:

  • línea 37: el parámetro de dirección [:id], que está ausente en una creación. La opción [transform] lo convierte en un número ([numberAttribute]);
  • línea 44: ¿creación o modificación?
  • líneas 46–48: el formulario, sin validador (el servidor lo valida todo), y su envío;
  • líneas 51–67: para una actualización, se lee el registro, incluida su versión; se actualizará con los cambios (bloqueo optimista). Un registro inexistente (/doctors/999/edit) redirige a la lista con un mensaje;
  • líneas 69–85: el guardado. Si tiene éxito, se prepara un mensaje flash y se redirige al usuario a la lista (líneas 75 y 78–79). Si otro administrador ha eliminado un registro entretanto, también se redirige al usuario a la lista (líneas 80–84); cualquier otro error deja el formulario mostrado, junto con sus errores.
<div class="row justify-content-center">
  <div class="col-md-8 col-lg-6">
    <div class="card p-4">
      <h5 class="card-title mb-3">{{ (creating() ? keys().add : keys().edit) | translate }}</h5>
      <!-- novalidate: es el SERVIDOR quien valida (es la referencia) -->
      <form novalidate (submit)="save($event)">
        <app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />

        <h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
        <app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" [formField]="f.login"
                          [help]="creating() ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT'" />
        <!-- nunca se rellena previamente: la contraseña nunca regresa del servidor -->
        <app-input-field class="mb-4" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" [maxChars]="72"
                          autocomplete="new-password" [formField]="f.password" [params]="submission.params()"
                          [help]="creating() ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'" />

        <div class="d-flex gap-2">
          <button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'PERSONS.SAVE' | translate }}</button>
          <a class="btn btn-secondary" [routerLink]="['/', type()]">{{ 'PERSONS.BACK' | translate }}</a>
        </div>
      </form>
    </div>
  </div>
</div>
  • línea 6: [novalidate]: el servidor valida el formulario;
  • línea 7: título, nombre y apellido, en un solo componente;
  • líneas 10–15: el nombre de usuario y la contraseña, con un mensaje de ayuda distinto para la creación y la modificación. La contraseña nunca se rellena previamente: el servidor nunca la devuelve;
  • línea 14: parámetros de los mensajes de error devueltos por el servidor (la longitud mínima de la contraseña, por ejemplo).

10.4.9.6. src/app/pages/register

// =========================================================================
// pages/register/register.ts - "Create a patient account" (/register)
// -------------------------------------------------------------------------
// Solo se llega aquí después de copiar el captcha de la página de inicio de sesión
// (botón "Create a patient account"): el servidor emitió entonces un
// pase, que el guardia de la ruta ha verificado (vea guards.ts).
// Los mismos campos que el formulario del ADMIN, pero el login y la contraseña
// son obligatorios, con confirmación. Equivalente de
// views/account/registration.hbs de la aplicación HTML.
// =========================================================================

import { Component, computed, inject, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { Registration } from '../../api/types';
import { MessagesService } from '../../services/messages.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';

// longitud mínima de una contraseña elegida por un paciente: el mismo valor
// que el servidor (que también devuelve {min} con el error PASSWORD_TOO_SHORT)
const PASSWORD_MIN = '6';

@Component({
  selector: 'app-register',
  imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
  templateUrl: './register.html',
})
export default class RegisterPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly messages = inject(MessagesService);
  private readonly router = inject(Router);

  protected readonly model = signal<Registration>({ title: 'Mr', firstName: '', lastName: '', login: '', password: '', confirmation: '' });
  protected readonly f = form(this.model);
  protected readonly submission = new FormSubmission(this.f);
  // los parámetros del mensaje de ayuda Y de los errores de la contraseña
  protected readonly passwordParams = computed(() => ({ min: PASSWORD_MIN, ...this.submission.params() }));

  protected async create(event: Event): Promise<void> {
    event.preventDefault();
    let login = '';
    const succeeded = await this.submission.submit(async () => {
      login = (await this.api.register(this.model())).login;
    });
    if (succeeded) {
      // de vuelta a la página de inicio de sesión, con el login rellenado
      this.messages.flash('success', 'REGISTRATION.DONE', { login });
      this.router.navigate(['/login'], { queryParams: { login } });
    } else if (this.messages.error()?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
      // pase vencido (15 minutos): de vuelta al captcha
      this.messages.flash('error', 'ERRORS.CAPTCHA_BEFORE_ACCOUNT');
      this.router.navigate(['/login']);
    }
  }
}

Creación de una cuenta de paciente. Aquí solo se puede continuar con el token emitido por el servidor tras resolver el CAPTCHA (guards.ts):

  • línea 25: la longitud mínima de la contraseña; para el mensaje de ayuda: el mismo valor que el del servidor;
  • línea 41: los parámetros del mensaje de ayuda y de los mensajes de error de la contraseña. Los parámetros del servidor, si se devuelve alguno, tienen prioridad (se colocan al final);
  • líneas 46–48: envío; el servidor devuelve el nombre de usuario de la cuenta creada;
  • líneas 49–52: regreso a la página de inicio de sesión, con el nombre de usuario rellenado previamente;
  • líneas 53–57: el token ha expirado (15 minutos): regreso al CAPTCHA.
<div class="row justify-content-center">
  <div class="col-md-8 col-lg-6">
    <div class="card p-4">
      <h5 class="card-title mb-1">{{ 'REGISTRATION.TITLE' | translate }}</h5>
      <p class="text-muted small mb-3">{{ 'REGISTRATION.INTRO' | translate }}</p>
      <form novalidate (submit)="create($event)">
        <app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />

        <h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
        <app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" autocomplete="username"
                          mandatory [formField]="f.login" help="REGISTRATION.LOGIN_HELP" />
        <div class="row g-3 mb-3">
          <app-input-field class="col-sm-6" fieldId="password" type="password" label="PERSONS.PASSWORD_LABEL" [maxChars]="72"
                            autocomplete="new-password" mandatory [formField]="f.password" [params]="passwordParams()"
                            help="REGISTRATION.PASSWORD_HELP" />
          <app-input-field class="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
                            [maxChars]="72" autocomplete="new-password" mandatory [formField]="f.confirmation" />
        </div>
        <div class="d-flex gap-2">
          <button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'REGISTRATION.SUBMIT' | translate }}</button>
          <a class="btn btn-secondary" routerLink="/login">{{ 'REGISTRATION.BACK_TO_LOGIN' | translate }}</a>
        </div>
      </form>
    </div>
  </div>
</div>
  • línea 7: título, nombre, apellido;
  • líneas 10–17: nombre de usuario, contraseña y confirmación de la contraseña, obligatorios esta vez (el atributo [mandatory] solo ofrece una indicación: el servidor decide).

10.4.9.7. src/app/pages/patient-area

// =========================================================================
// pages/patient-area/patient-area.ts - "My area" (/my-area, rol USER)
// -------------------------------------------------------------------------
// La página de inicio del paciente, justo después de iniciar sesión:
//   - dos opciones: [Manage my account] y [View a schedule];
//   - su próxima cita, si la tiene, con el medio para cancelarla.
// Equivalente de views/patient/area.hbs de la aplicación HTML.
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { MyArea } from '../../api/types';
import { TimeRangePipe, LongDatePipe, LabelPipe } from '../../pipes/formatting.pipes';
import { LanguageService } from '../../i18n/language.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';

@Component({
  selector: 'app-patient-area',
  imports: [RouterLink, TranslatePipe, TimeRangePipe, LongDatePipe, LabelPipe],
  templateUrl: './patient-area.html',
})
export default class PatientAreaPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly messages = inject(MessagesService);
  private readonly confirmation = inject(ConfirmationService);
  protected readonly language = inject(LanguageService).language;

  protected readonly area = signal<MyArea | null>(null);

  constructor() {
    this.load();
  }

  private async load(): Promise<void> {
    try {
      this.area.set(await this.api.myArea());
    } catch (e) {
      this.messages.showApiError(e);
    }
  }

  protected async cancel(appointmentId: number): Promise<void> {
    if (!(await this.confirmation.confirm('SCHEDULE.CANCEL_CONFIRM'))) {
      return;
    }
    try {
      await this.api.cancelAppointment(appointmentId);
      this.messages.showSuccess('SCHEDULE.CANCELLED');
    } catch (e) {
      this.messages.showApiError(e);
    }
    await this.load();
  }
}

La página de inicio del paciente: dos opciones («Administrar mi cuenta», «Ver una agenda») y su próxima cita, que puede cancelar (líneas 45–56).

@if (area(); as a) {
  <h4 class="mb-3">{{ 'AREA.HELLO' | translate: { name: (a.patient | label) } }}</h4>
  <div class="row g-3 mb-4">
    <div class="col-sm-6">
      <a class="card p-4 h-100 text-decoration-none option-card" routerLink="/my-account">
        <h5 class="mb-1">{{ 'AREA.MANAGE_ACCOUNT' | translate }}</h5>
        <span class="text-muted">{{ 'AREA.MANAGE_ACCOUNT_HELP' | translate }}</span>
      </a>
    </div>
    <div class="col-sm-6">
      <a class="card p-4 h-100 text-decoration-none option-card" routerLink="/schedule">
        <h5 class="mb-1">{{ 'AREA.VIEW_SCHEDULE' | translate }}</h5>
        <span class="text-muted">{{ 'AREA.VIEW_SCHEDULE_HELP' | translate }}</span>
      </a>
    </div>
  </div>

  <div class="card p-3">
    <h5>{{ 'AREA.MY_APPOINTMENT' | translate }}</h5>
    <!-- normalmente solo una (regla "una cita próxima a la vez"),
         pero la página puede mostrar varias -->
    @for (appointment of a.appointments; track appointment.id; let last = $last) {
      <div class="d-flex flex-wrap justify-content-between align-items-center gap-2 py-2" [class.border-bottom]="!last">
        <div>
          <div class="fw-semibold">{{ appointment.day | longDate: language() }}, {{ appointment.slot | timeRange }}</div>
          <div class="text-muted">
            {{ appointment.doctor | label }} -
            <!-- la agenda del médico en ese día: el paciente ve allí su nombre -->
            <a routerLink="/schedule" [queryParams]="{ doctorId: appointment.doctor.id, day: appointment.day }">{{ 'AREA.SEE_IN_SCHEDULE' | translate }}</a>
          </div>
        </div>
        <button type="button" class="btn btn-outline-danger" (click)="cancel(appointment.id)">{{ 'AREA.CANCEL_APPOINTMENT' | translate }}</button>
      </div>
    } @empty {
      <p class="text-muted mb-0">{{ 'AREA.NO_APPOINTMENT' | translate }}</p>
    }
  </div>
} @else {
  <p class="text-muted">{{ 'APP.LOADING' | translate }}</p>
}
  • línea 2: un parámetro de traducción calculado por un pipe;
  • línea 22: [$last]: la última fila no tiene borde;
  • línea 29: un enlace al calendario del médico para ese día.

10.4.9.8. src/app/pages/my-account

// =========================================================================
// pages/my-account/my-account.ts - "Manage my account" (/my-account, rol USER)
// -------------------------------------------------------------------------
// Dos formularios independientes, como views/patient/account.hbs:
//   1. la actualización (identidad, login, nueva contraseña opcional);
//   2. la eliminación de la cuenta - que también cancela sus citas.
// Ambos requieren la contraseña ACTUAL (verificada por el servidor).
// Dos formularios, por lo tanto dos modelos, dos árboles de campos y dos
// objetos FormSubmission (dos conjuntos de errores).
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import { form, FormField } from '@angular/forms/signals';
import { TranslatePipe } from '@ngx-translate/core';
import { RdvMedecinsApi } from '../../api/rdvmedecins.api';
import { MyAccountUpdate } from '../../api/types';
import { SessionService } from '../../services/session.service';
import { MessagesService } from '../../services/messages.service';
import { ConfirmationService } from '../../services/confirmation.service';
import { FormSubmission } from '../../services/form-submission';
import { PersonFields } from '../../components/person-fields';
import { InputField } from '../../components/input-field';

@Component({
  selector: 'app-my-account',
  imports: [RouterLink, FormField, TranslatePipe, PersonFields, InputField],
  templateUrl: './my-account.html',
})
export default class MyAccountPage {
  private readonly api = inject(RdvMedecinsApi);
  private readonly session = inject(SessionService);
  private readonly messages = inject(MessagesService);
  private readonly confirmation = inject(ConfirmationService);
  private readonly router = inject(Router);

  // 1. la actualización
  protected readonly model = signal<MyAccountUpdate>({
    title: 'Mr',
    firstName: '',
    lastName: '',
    login: '',
    password: '',
    confirmation: '',
    currentPassword: '',
    version: 0,
  });
  protected readonly f = form(this.model);
  protected readonly update = new FormSubmission(this.f);

  // 2. la eliminación: un formulario con un solo campo
  protected readonly deletionModel = signal({ currentPassword: '' });
  protected readonly fs = form(this.deletionModel);
  protected readonly deletion = new FormSubmission(this.fs);

  constructor() {
    this.load();
  }

  private async load(): Promise<void> {
    try {
      const account = await this.api.myAccount();
      this.model.update((m) => ({ ...m, ...account }));
    } catch (e) {
      this.messages.showApiError(e);
    }
  }

  protected async save(event: Event): Promise<void> {
    event.preventDefault();
    const succeeded = await this.update.submit(async () => {
      // el servidor ha emitido un token NUEVO (nombre, login): la barra de
      // navegación debe seguirlo
      this.session.update(await this.api.editMyAccount(this.model()));
      this.messages.flash('success', 'MY_ACCOUNT.UPDATED');
    });
    if (succeeded) {
      this.router.navigate(['/my-area']);
    } else {
      // nunca una contraseña que quede en el campo tras un envío rechazado;
      // se modifica el campo mismo (y no el modelo) para no borrar los errores
      // que el servidor acaba de asociarle... excepto el suyo
      this.f.currentPassword().value.set('');
    }
  }

  protected async deleteAccount(event: Event): Promise<void> {
    event.preventDefault();
    if (!(await this.confirmation.confirm('MY_ACCOUNT.DELETE_CONFIRM'))) {
      return;
    }
    const succeeded = await this.deletion.submit(() => this.api.deleteMyAccount(this.deletionModel().currentPassword));
    if (succeeded) {
      this.session.forget(); // el servidor ha borrado la cookie del token
      this.messages.flash('success', 'MY_ACCOUNT.DELETED');
      this.router.navigate(['/login']);
    }
  }
}

Dos formularios independientes: modificación de la cuenta y eliminación de la cuenta. Ambos requieren la contraseña actual, que verifica el servidor. Dos formularios, por lo tanto dos modelos, dos árboles de campos y dos [FormSubmission]: los errores de uno no aparecen en el otro.

  • Líneas 60–67: se lee la cuenta y sus valores se copian en el modelo (incluida la versión);
  • línea 74: después de un cambio, el servidor devuelve el usuario actualizado (y ha emitido un nuevo token): la barra de navegación debe actualizarse en consecuencia;
  • Línea 83: tras un envío rechazado, se borra la contraseña actual. Actualizamos el campo (no el formulario completo): solo desaparece el error de ese campo; los demás permanecen visibles;
  • líneas 87–98: eliminación de la cuenta, tras la confirmación. El servidor ha eliminado la cookie del token: se olvida al usuario y la página vuelve a la página de inicio de sesión.
<div class="row justify-content-center">
  <div class="col-md-8 col-lg-6">
    <!-- 1. actualización -->
    <div class="card p-4 mb-4">
      <h5 class="card-title mb-3">{{ 'MY_ACCOUNT.TITLE' | translate }}</h5>
      <form novalidate (submit)="save($event)">
        <app-person-fields [title]="f.title" [firstName]="f.firstName" [lastName]="f.lastName" />

        <h6 class="mt-4 text-muted">{{ 'PERSONS.ACCOUNT_SECTION' | translate }}</h6>
        <app-input-field class="mb-3" fieldId="login" label="PERSONS.LOGIN_LABEL" [maxChars]="30" autocomplete="username"
                          mandatory [formField]="f.login" />
        <div class="row g-3 mb-3">
          <app-input-field class="col-sm-6" fieldId="password" type="password" label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
                            [maxChars]="72" autocomplete="new-password" [formField]="f.password"
                            [params]="update.params()" help="PERSONS.PASSWORD_HELP_EDIT" />
          <app-input-field class="col-sm-6" fieldId="confirmation" type="password" label="ACCOUNT.CONFIRMATION_LABEL"
                            [maxChars]="72" autocomplete="new-password" [formField]="f.confirmation" />
        </div>
        <app-input-field class="mb-4" fieldId="currentPassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
                          [maxChars]="72" autocomplete="current-password" mandatory [formField]="f.currentPassword"
                          help="MY_ACCOUNT.CURRENT_PASSWORD_HELP" />
        <div class="d-flex gap-2">
          <button type="submit" class="btn btn-primary" [disabled]="f().submitting()">{{ 'PERSONS.SAVE' | translate }}</button>
          <a class="btn btn-secondary" routerLink="/my-area">{{ 'MY_ACCOUNT.BACK' | translate }}</a>
        </div>
      </form>
    </div>

    <!-- 2. eliminación -->
    <div class="card p-4 border-danger">
      <h5 class="card-title text-danger mb-1">{{ 'MY_ACCOUNT.DELETE_TITLE' | translate }}</h5>
      <p class="text-muted small">{{ 'MY_ACCOUNT.DELETE_HELP' | translate }}</p>
      <form class="d-flex flex-wrap gap-2 align-items-end" novalidate (submit)="deleteAccount($event)">
        <app-input-field class="flex-grow-1" fieldId="deletePassword" type="password" label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
                          [maxChars]="72" autocomplete="current-password" mandatory [formField]="fs.currentPassword" />
        <button type="submit" class="btn btn-danger" [disabled]="fs().submitting()">{{ 'MY_ACCOUNT.DELETE_SUBMIT' | translate }}</button>
      </form>
    </div>
  </div>
</div>

10.4.9.9. src/app/pages/error/error.ts

// =========================================================================
// pages/error/error.ts - la página de error: 404 (dirección desconocida) o 403
// (rol insuficiente, vea guards.ts). Equivalente de views/error.hbs.
// El código llega como input, a partir de los datos de la ruta (data.code).
// =========================================================================

import { Component, computed, input } from '@angular/core';
import { RouterLink } from '@angular/router';
import { TranslatePipe } from '@ngx-translate/core';

@Component({
  selector: 'app-error',
  imports: [RouterLink, TranslatePipe],
  template: `
    <div class="card p-4">
      <h4 class="text-danger">{{ 'ERROR_PAGE.TITLE' | translate }} {{ code() }}</h4>
      <p>{{ message() | translate }}</p>
      <a routerLink="/" class="btn btn-primary align-self-start">{{ 'ERROR_PAGE.BACK' | translate }}</a>
    </div>
  `,
})
export default class ErrorPage {
  readonly code = input.required<403 | 404>();
  protected readonly message = computed(() => (this.code() === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND'));
}

La página de error, 403 o 404: el código se pasa como entrada a partir de los datos de la ruta ([data.code]).