Skip to content

6. Capítulo 5 - O cliente [Angular] da aplicação [RdvMedecins]

Este capítulo detalha, arquivo por arquivo, o conteúdo da pasta [rdvmedecins-angular-client] incluída neste documento, usando o formato adotado ao longo deste curso: código-fonte numerado linha a linha, seguido de uma seção intitulada “Vamos comentar este código:”. Cada pasta de projeto também contém seu próprio arquivo README.md.

6.1. Visão geral da arquitetura

Como no documento original, o cliente segue uma arquitetura em camadas, que chamaremos aqui de V-C-Services (View-Controller-Services):

Image

Vale destacar uma diferença de terminologia: no AngularJS 1.x, a View (o template HTML) e o Controller (a classe JavaScript associada) eram duas entidades distintas, ligadas por $scope. No [Angular], elas são reunidas em uma única entidade, o componente (veja o capítulo anterior) — e é por isso que, daqui em diante, falaremos simplesmente em “componentes” onde o documento original distinguia entre view e controller.

Como no documento original, os componentes NUNCA se comunicam diretamente com o servidor: esse papel é reservado exclusivamente à camada de serviços. Trata-se de um princípio de projeto que se aplica igualmente ao AngularJS 1.x e ao [Angular] — não mudou.

6.2. Árvore do projeto

Image

Esta estrutura segue diretamente o fluxo do documento original (login, seleção de médico/dia, exibição da agenda, marcação de consulta), organizada aqui simplesmente em componentes [Angular] standalone, em vez de controllers e views separados do AngularJS 1.x.

O Bootstrap é usado em todas as views ([node_modules/bootstrap/dist/css/bootstrap.min.css], declarado em angular.json) — uma evolução direta do Bootstrap 3, que já era usado pelo documento original.

6.3. Arquivos de configuração do projeto

Image

6.3.1. package.json

{
  "name": "rdvmedecins-angular-client",
  "version": "0.0.0",
  "scripts": {
    "ng": "ng",
    "start": "ng serve",
    "build": "ng build",
    "watch": "ng build --watch --configuration development",
    "test": "ng test"
  },
  "private": true,
  "packageManager": "npm@10.9.7",
  "dependencies": {
    "@angular/common": "^22.1.0",
    "@angular/compiler": "^22.1.0",
    "@angular/core": "^22.1.0",
    "@angular/forms": "^22.1.0",
    "@angular/platform-browser": "^22.1.0",
    "@angular/router": "^22.1.0",
    "@ngx-translate/core": "^18.0.0",
    "@ngx-translate/http-loader": "^18.0.0",
    "bootstrap": "^5.3.3",
    "rxjs": "~7.8.0",
    "tslib": "^2.3.0"
  },
  "devDependencies": {
    "@angular/build": "^22.1.0",
    "@angular/cli": "^22.1.0",
    "@angular/compiler-cli": "^22.1.0",
    "prettier": "^3.8.1",
    "typescript": "~6.0.0"
  }
}

Vamos comentar este código:

  • linhas 4–10: [“scripts”: { … }] — os comandos `npm run <name>` disponíveis. `start` (`ng serve`) inicia o servidor de desenvolvimento com recarga automática sempre que um arquivo-fonte é modificado — é o comando usado ao longo deste documento;
  • linhas 13–25: [“dependencies”: { … }] — os pacotes necessários para executar a aplicação no navegador: o núcleo do [Angular] ([@angular/core], [@angular/common], [@angular/compiler], [@angular/forms], [@angular/platform-browser], [@angular/router]), o Bootstrap (apenas a folha de estilo; veja angular.json), o RxJS (os Observables usados pelo [HttpClient]) e — introduzidos neste capítulo — [@ngx-translate/core] e [@ngx-translate/http-loader], a biblioteca de terceiros usada para a tradução FR/EN da interface (veja [LanguageService] e app.config.ts abaixo);
  • linhas 26–32: [“devDependencies”: { … }] — pacotes necessários apenas durante o desenvolvimento (CLI, compilador), nunca incluídos no bundle final entregue ao navegador: @angular/cli/@angular/build (o CLI e seu mecanismo de compilação), [@angular/compiler-cli] (compilação de templates ahead-of-time), TypeScript e Prettier (formatação automática de código, não usado neste documento, mas incluído em todo projeto [Angular] gerado por padrão).

Ao contrário do servidor [NestJS] (módulos commonjs, veja o Capítulo 3), um projeto [Angular] padrão é executado como módulos ECMAScript nativos (import/export) — isso se reflete abaixo em "module": "preserve" no tsconfig.json.

6.3.2. angular.json

  {
    "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
    "version": 1,
    "cli": { "packageManager": "npm" },
    "newProjectRoot": "projects",
    "projects": {
      "rdvmedecins-angular-client": {
        "projectType": "application",
        "root": "",
       "sourceRoot": "src",
       "prefix": "app",
       "architect": {
         "build": {
           "builder": "@angular/build:application",
           "options": {
             "browser": "src/main.ts",
             "tsConfig": "tsconfig.app.json",
             "assets": [
               { "glob": "**/*", "input": "public" }
             ],
             "styles": [
               "node_modules/bootstrap/dist/css/bootstrap.min.css",
               "src/styles.css"
             ]
           },
           "configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
           "defaultConfiguration": "production"
         },
         "serve": {
           "builder": "@angular/build:dev-server",
           "configurations": { "production": { "...": "..." }, "development": { "...": "..." } },
           "defaultConfiguration": "development"
         }
       }
     }
   }
 }

Vamos comentar este código (algumas linhas foram condensadas acima para facilitar a leitura — o arquivo entregue está completo):

  • linha 11: [“prefix”: “app”,] — o prefixo aplicado ao seletor de cada componente do projeto (app-login, app-schedule etc.) — uma convenção, imposta pelo compilador, que evita colisões de nomes com eventuais componentes de terceiros;
  • linha 16: [“browser”: “src/main.ts”,] — o ponto de entrada da compilação — o mesmo arquivo explicado mais adiante neste capítulo;
  • linhas 18–20: [“assets”: [ { “glob”: “**/*”, “input”: “public” } ],] — copia todo o conteúdo da pasta public/, tal como está, para a raiz da aplicação compilada — é esse mecanismo que permite que public/i18n/fr.json seja acessível na URL /i18n/fr.json, o endereço consultado pelo TranslateHttpLoader (veja mais adiante neste capítulo);
  • linhas 21–24: [“styles”: [ “node_modules/bootstrap/dist/css/bootstrap.min.css”, “src/styles.css” ],] — as folhas de estilo globais, concatenadas nesta ordem em tempo de compilação: primeiro o Bootstrap (para que nossas próprias regras, em [styles.css], possam sobrescrevê-lo se necessário), sem usar uma instrução @import padrão do CSS.

Este arquivo não tem equivalente no projeto AngularJS 1.x original (as ferramentas de compilação da época — Grunt, Gulp — eram configuradas separadamente); no projeto [NestJS] (Capítulo 3), o nest-cli.json cumpre uma função semelhante, mas de maneira mais simples.

6.3.3. [tsconfig.json]

  {
    "compileOnSave": false,
    "compilerOptions": {
      "strict": true,
      "noImplicitOverride": true,
      "noPropertyAccessFromIndexSignature": true,
      "noImplicitReturns": true,
      "noFallthroughCasesInSwitch": true,
      "skipLibCheck": true,
     "isolatedModules": true,
     "experimentalDecorators": true,
     "importHelpers": true,
     "target": "ES2022",
     "module": "preserve"
   },
   "angularCompilerOptions": {
     "enableI18nLegacyMessageIdFormat": false,
     "strictInjectionParameters": true,
     "strictInputAccessModifiers": true,
     "strictTemplates": true
   },
   "files": [],
   "references": [
     { "path": "./tsconfig.app.json" }
   ]
 }

Vamos detalhar este código:

  • linha 4: [“strict”: true,] — ao contrário do servidor [NestJS] (que habilita apenas strictNullChecks isoladamente; veja o Capítulo 3), o cliente habilita o modo estrito completo do TypeScript: toda variável deve ter um tipo determinável e todo valor null/undefined deve ser tratado explicitamente. É uma escolha mais rigorosa, coerente com o fato de este documento apresentar o [Angular] como a referência de “boas práticas atuais”;
  • linha 20: [“strictTemplates”: true]—a opção mais importante deste arquivo: ela estende a verificação de tipos do TypeScript para os templates HTML em si ([app.html], schedule.component.html…). Um erro como {{ doctor.lastNamee }} (erro de digitação) ou [canEdit]="auth.isAdmin" (parênteses ausentes) é então apontado durante a compilação, exatamente como um erro em um arquivo .ts — o que não acontecia no AngularJS 1.x (2014), em que um template assim sempre compilava, e o erro só se tornava aparente em tempo de execução (silenciosamente, na maioria das vezes);
  • Linhas 22–25: [“files”: [], “references”: [ { “path”: “./tsconfig.app.json” } ]] — este arquivo raiz não compila diretamente nenhum arquivo ("files": []): ele delega ao tsconfig.app.json (abaixo) por meio do mecanismo de referências de projeto do TypeScript, que permite que um único projeto [Angular] defina, no fim, várias configurações de build distintas (aplicação, testes etc.) que compartilham uma base comum.

6.3.4. tsconfig.app.json

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

Vamos comentar este código:

  • linha 2: [“extends”: “./tsconfig.json”,] — parte da base comum (modo estrito, target ES2022…) em vez de redefinir tudo;
  • linha 8: [“src/**/*.ts”] — todos os arquivos .ts do projeto, incluindo (por exemplo) language.service.ts, adicionado por este capítulo;
  • linha 11: [“src/**/*.spec.ts”] — os arquivos de testes unitários (ausentes deste projeto, mas excluídos por convenção) são compilados separadamente, com sua própria configuração — não abordada neste documento.

6.4. Inicialização da aplicação

Image

6.4.1. src/index.html

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>RdvMedecins - Angular client</title>
  <base href="/">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="icon" type="image/x-icon" href="favicon.ico">
</head>
<body>
  <app-root></app-root>
</body>
</html>

Vamos comentar este código:

  • linha 2: [<html lang="en">] — o idioma padrão da página, útil para acessibilidade e mecanismos de busca. Como esta página HTML é estática (carregada pelo navegador ANTES de a aplicação [Angular] iniciar), ela obviamente não pode refletir imediatamente uma escolha de idioma feita depois pelo usuário; é o [LanguageService] (veja abaixo) que atualiza dinamicamente este atributo assim que o usuário muda para o francês;
  • linha 11: [] — o seletor do componente raiz ([App], veja app.ts: selector: 'app-root'): é o único elemento que a página contém inicialmente, e o [Angular] o preenche inteiramente assim que inicia. Isso segue exatamente o mesmo princípio do AngularJS 1.x (2014), que definia ng-app="rdvmedecinsApp" na tag <html> do arquivo [app.html] do projeto original — uma página HTML quase vazia, inteiramente controlada pelo framework JavaScript.

6.4.2. [src/main.ts]

1
2
3
4
5
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { App } from './app/app';

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

Vamos comentar este código:

  • linha 5: [bootstrapApplication(App, appConfig).catch((err) => console.error(err));] — inicia a aplicação especificando o componente raiz ([App]) e sua configuração (appConfig; veja app.config.ts abaixo) ; bootstrapApplication é a função de inicialização das aplicações [Angular] standalone (sem NgModule), que substitui platformBrowserDynamic().bootstrapModule([AppModule]) das versões mais antigas do Angular. .catch(...) captura quaisquer erros que ocorram durante a própria inicialização (antes de qualquer linha do código da aplicação ser executada) — um cenário raro e grave o bastante para merecer um tratamento separado do tratamento de erros habitual da aplicação.

Há um único ponto de entrada para toda a aplicação: essa é a própria definição de uma aplicação web de página única (SPA), como já descrito no documento original.

6.4.3. [src/styles.css]

body {
  background-color: #f5f7fa;
}

.free-slot {
  cursor: pointer;
}

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

Vamos comentar este código:

  • linha 1: [body { background-color: #f5f7fa; }] — um cinza bem claro em vez do branco puro padrão, para que os cards do Bootstrap (fundo branco, .card) se destaquem levemente do fundo da página;
  • linhas 5–10: [.free-slot] — aplicada às linhas da tabela do calendário que representam um horário disponível (veja schedule.component.html, [class.free-slot]="scheduleSlot.appointment === null"): o cursor muda para uma mão (cursor: pointer) e o fundo fica levemente verde ao passar o mouse, para sugerir que a linha é clicável — mesmo antes de clicar nela.

Este arquivo contém estilos globais, em oposição aos estilos “locais” definidos no arquivo .css de cada componente (schedule.component.css…), que se aplicam apenas ao template desse componente específico. O src/app/app.css, a folha de estilo do componente raiz, permanece vazio: o Bootstrap e o [styles.css] bastam para tudo o que este documento implementa.

6.5. A camada core/models

Image

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

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

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

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

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

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

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

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

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

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

Vamos comentar este código:

  • linhas 1–4: [export interface ServerResponse { status: number; data: T | null; }] — corresponde exatamente à classe do servidor [ServerResponse]<T> (veja o Capítulo 3): toda resposta JSON tem essa forma;
  • linhas 6–18: [Doctor / Client] — duas interfaces de forma idêntica, correspondentes às entidades [TypeORM] de mesmo nome (Capítulo 3). Lembrete: [Client] refere-se aqui a um paciente, e não a um “cliente HTTP”;
  • linhas 20–33: [SlotJson / AppointmentJson] — as versões “leves” geradas no lado do servidor por getMapForSlot/getMapForAppointment (Capítulo 3, static.helper.ts);
  • linhas 40–44: [export interface DoctorDaySchedule { … }] — corresponde à resposta de GET /getDoctorScheduleOfDay/:doctorId/:day;
  • linha 46: [export type Role = ‘ADMIN’ | ‘USER’;] — uma cópia exata do tipo [Role] do servidor (src/entities/user.entity.ts);
  • Linhas 48–53: [export interface LoginResult { … }] — o formato dos dados retornados por POST /login (veja o [AuthService] abaixo), uma cópia exata da interface de mesmo nome do servidor (auth/login-result.model.ts).

No AngularJS 1.x (2014), o JavaScript original não permitia descrever dessa forma o formato de dados esperado: uma resposta do servidor era tratada como um objeto qualquer, sem nenhuma validação antes da execução. Com o TypeScript, um erro de digitação no nome de um campo agora é apontado antes mesmo de o programa ser executado — durante a compilação.

6.6. A camada core/services

Image

6.6.1. src/app/core/services/settings.service.ts

  import { Injectable, signal } from '@angular/core';

  @Injectable({ providedIn: 'root' })
  export class SettingsService {
    readonly apiBaseUrl = signal('http://localhost:8080');

    setApiBaseUrl(url: string): void {
      this.apiBaseUrl.set(url);
    }
 }

Vamos comentar este código:

  • Linha 3: [@Injectable({ providedIn: 'root' })] — declara um serviço como um singleton global da aplicação: o [Angular] cria automaticamente uma única instância dele na primeira vez que um componente precisa dele — o equivalente moderno de um serviço que o AngularJS 1.x declarava com .service() ou .factory();
  • Linha 5: [readonly apiBaseUrl = signal(‘http://localhost:8080’);] — signal(...) cria um valor reativo: quem ler apiBaseUrl() em um template [Angular] será notificado automaticamente se seu valor mudar - o mecanismo central de reatividade do [Angular] moderno, que substitui a observação ($watch/$scope.$apply) do AngularJS 1.x;
  • linhas 7–9: [setApiBaseUrl(url: string): void { this.apiBaseUrl.set(url); }] — extraído do campo “URL do servidor” da view inicial do documento original, que já permitia ao usuário modificá-la pela interface (útil se o servidor estiver rodando em outra porta).

6.6.2. src/app/core/services/appointment.service.ts

  import { Injectable, inject } from '@angular/core';
  import { HttpClient } from '@angular/common/http';
  import { Observable, map } from 'rxjs';
  import { SettingsService } from './settings.service';
  import { DoctorDaySchedule, Client, Doctor, ServerResponse, AppointmentJson } from '../models/appointment.models';

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

   getAllDoctors(): Observable<Doctor[]> {
     return this.http
       .get<ServerResponse<Doctor[]>>(`${this.settings.apiBaseUrl()}/getAllDoctors`)
       .pipe(map((response) => this.extract(response)));
   }

   getAllClients(): Observable<Client[]> {
     return this.http
       .get<ServerResponse<Client[]>>(`${this.settings.apiBaseUrl()}/getAllClients`)
       .pipe(map((response) => this.extract(response)));
   }

   getDoctorScheduleOfDay(doctorId: number, day: string): Observable<DoctorDaySchedule> {
     return this.http
       .get<ServerResponse<DoctorDaySchedule>>(
         `${this.settings.apiBaseUrl()}/getDoctorScheduleOfDay/${doctorId}/${day}`,
       )
       .pipe(map((response) => this.extract(response)));
   }

   addAppointment(day: string, clientId: number, slotId: number): Observable<AppointmentJson> {
     return this.http
       .post<ServerResponse<AppointmentJson>>(`${this.settings.apiBaseUrl()}/addAppointment`, { day, clientId, slotId })
       .pipe(map((response) => this.extract(response)));
   }

   deleteAppointment(appointmentId: number): Observable<void> {
     return this.http
       .post<ServerResponse<null>>(`${this.settings.apiBaseUrl()}/deleteAppointment`, { appointmentId })
       .pipe(map(() => undefined));
   }

   private extract<T>(response: ServerResponse<T>): T {
     if (response.status !== 0) {
       throw new Error(`The server responded with error status ${response.status}`);
     }
     return response.data as T;
   }
 }

Vamos comentar este código:

  • linha 8: [export class AppointmentService {] — o equivalente direto do serviço DAO apresentado no capítulo “Exemplo 6: os serviços HTTP” do documento original (que usava o serviço $http do AngularJS). Ao contrário de uma aplicação tradicional do lado do servidor, em que a camada web se comunica com a camada DAO apenas por meio da camada de negócio, o cliente permite que a camada de apresentação (nossos componentes) chame este serviço diretamente — não existe uma “camada de negócio” separada no lado do cliente;
  • linha 9: [private readonly http = inject(HttpClient);] — `inject()` é a forma moderna de obter uma dependência no [Angular] (ela substitui a tradicional injeção pelo construtor);
  • Linhas 12–16: [getAllDoctors(): Observable<Doctor[]> { … }] — equivalente a GET /getAllDoctors; cada método corresponde exatamente a uma das onze rotas do controller [NestJS] (Capítulo 3) — de fato, os mesmos nomes aparecem nos dois lados, o que facilita a consulta cruzada entre o código do servidor e o do cliente;
  • linha 44: [private extract<T>(response: ServerResponse<T>): T {] — em vez de repetir a verificação “se status !== 0, é um erro” em cada um dos métodos públicos, nós a centralizamos aqui, uma única vez;
  • linha 46: [throw new Error(…)] — uma exceção JavaScript lançada em `map()` é redirecionada automaticamente pelo RxJS para o ramo `error` da inscrição (.subscribe({ next, error })) - Esse mecanismo permite que o componente raiz exiba uma mensagem de erro sem nunca precisar conhecer os detalhes do envelope [ServerResponse]<T>.

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

O serviço que gerencia a conexão do usuário: chama POST /login, armazena o token JWT recebido (e a identidade/papel que o acompanham) como signals e garante que ele sobreviva a um recarregamento da página usando localStorage. É o único outro local da aplicação, além do [AppointmentService], que se comunica com o servidor via HTTP — uma exceção intencional à regra do “serviço HTTP único”, que reflete, no lado do cliente, a separação já feita no lado do servidor entre RdvMedecinsController e AuthController.

  import { Injectable, computed, inject, signal } from '@angular/core';
  import { HttpClient } from '@angular/common/http';
  import { Observable, map, tap } from 'rxjs';
  import { SettingsService } from './settings.service';
  import { LoginResult, ServerResponse, Role } from '../models/appointment.models';

  interface StoredSession {
    accessToken: string;
    login: string;
   name: string;
   role: Role;
 }

 const STORAGE_KEY = 'rdvmedecins.session';

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

   private readonly session = signal<StoredSession | null>(readStoredSession());
   readonly isLoggedIn = computed(() => this.session() !== null);
   readonly login = computed(() => this.session()?.login ?? null);
   readonly name = computed(() => this.session()?.name ?? null);
   readonly role = computed(() => this.session()?.role ?? null);
   readonly isAdmin = computed(() => this.role() === 'ADMIN');

   readonly accessToken = computed(() => this.session()?.accessToken ?? null);

   logIn(login: string, password: string): Observable<LoginResult> {
     return this.http
       .post<ServerResponse<LoginResult>>(`${this.settings.apiBaseUrl()}/login`, { login, password })
       .pipe(
         map((response) => {
           if (response.status !== 0 || response.data === null) {
             throw new Error('Login failed');
           }
           return response.data;
         }),
         tap((result) => this.saveSession(result)),
       );
   }

   logOut(): void {
     this.session.set(null);
     localStorage.removeItem(STORAGE_KEY);
   }

   private saveSession(result: LoginResult): void {
     const newSession: StoredSession = result;
     this.session.set(newSession);
     localStorage.setItem(STORAGE_KEY, JSON.stringify(newSession));
   }
 }

 function readStoredSession(): StoredSession | null {
   try {
     const raw = localStorage.getItem(STORAGE_KEY);
     return raw ? (JSON.parse(raw) as StoredSession) : null;
   } catch {
     return null;
   }
 }

Vamos comentar este código:

  • linhas 7–12: [interface StoredSession { … }] — o formato do que é gravado em/lido de localStorage — um simples objeto JSON, distinto de [LoginResult] por projeto (embora inclua todos os seus campos);
  • linha 21: [private readonly session = signal<StoredSession | null>(readStoredSession());] — inicializado a partir de localStorage: se o usuário recarregar a página depois de fazer login, continua conectado (até o token expirar no lado do servidor ou ele sair explicitamente);
  • linha 22: [readonly isLoggedIn = computed(() => this.session() !== null);] — `computed()` cria um signal derivado: seu valor é recalculado automaticamente sempre que a sessão muda, e qualquer componente que o leia (auth.isLoggedIn() em [app.html]) é, por sua vez, notificado;
  • linhas 23–26: [login / name / role / isAdmin] — signals derivados, expostos como somente leitura aos componentes (app.ts, login.component.ts, schedule.component.ts via canEdit);
  • linha 28: [readonly accessToken = computed(() => this.session()?.accessToken ?? null);] — o token a ser incluído em cada requisição HTTP protegida, lido por auth.interceptor.ts (abaixo);
  • linha 30: [logIn(login: string, password: string): Observable {] — equivalente a POST /login, corpo JSON { login, password };
  • linhas 34–39: [map((response) => { if (response.status !== 0 …) { throw …; } return response.data; })] — mesmo princípio de AppointmentService.extract(), reescrito aqui em linha, em vez de uma chamada (nenhum método privado compartilhado entre os dois serviços, que permanecem intencionalmente independentes);
  • linha 40: [tap((result) => this.saveSession(result)),] — `tap()` executa um efeito colateral (aqui: salvar a sessão) sem alterar o valor repassado em seguida ao assinante — ao contrário de `map()`, que transforma esse valor;
  • linhas 44–47: [logOut(): void { this.session.set(null); localStorage.removeItem(…); }] — puramente local (nenhuma chamada ao servidor): um token JWT não é “revogado” no lado do servidor neste port inicial; ele expira por conta própria após JWT_EXPIRES_IN;
  • Linha 56: [function readStoredSession(): StoredSession | null {] — protegida por um bloco try/catch: o localStorage pode estar indisponível (devido a uma navegação privada muito restritiva) ou conter um valor corrompido — caso em que simplesmente se supõe que não há sessão.

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

Um pequeno serviço que centraliza a troca de idioma da interface (francês/inglês). Ele se apoia no [TranslateService] ([@ngx-translate/core], configurado em app.config.ts abaixo) para o trabalho de tradução propriamente dito, e acrescenta o que já se encontra no [SettingsService] e no [AuthService]: um signal exposto ao restante da aplicação e o armazenamento da escolha do usuário em localStorage.

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

  const STORAGE_KEY = 'rdvmedecins.language';

  export type Language = 'fr' | 'en';

  @Injectable({ providedIn: 'root' })
  export class LanguageService {
   private readonly translate = inject(TranslateService);

   readonly currentLanguage = this.translate.currentLang;

   constructor() {
     const initialLanguage = (localStorage.getItem(STORAGE_KEY) as Language | null) ?? (navigator.language?.toLowerCase().startsWith('fr') ? 'fr' : null);
     if (initialLanguage && initialLanguage !== this.translate.getCurrentLang()) {
       this.applyLanguage(initialLanguage);
     }
   }

   changeLanguage(language: Language): void {
     localStorage.setItem(STORAGE_KEY, language);
     this.applyLanguage(language);
   }

   private applyLanguage(language: Language): void {
     this.translate.use(language).subscribe(() => {
       document.documentElement.lang = language;
     });
   }
 }

Vamos detalhar este código:

  • linha 10: [private readonly translate = inject(TranslateService);] — o [TranslateService] é o serviço central do [@ngx-translate/core]: ele é responsável por carregar um dicionário de tradução e resolver uma chave ('LOGIN.TITLE') em texto ('Login' ou 'Connexion', dependendo do idioma atual);
  • Linha 12: [readonly currentLanguage = this.translate.currentLang;] — desde a versão 18 do [@ngx-translate/core], o [TranslateService] já expõe currentLang como um signal: não há necessidade de recriar um aqui, apenas o republicamos com este nome — para que o restante do código da aplicação (veja [app.html]) nunca precise importar o próprio [TranslateService], apenas o [LanguageService];
  • linhas 14–19: [constructor() { const initialLanguage = …; if (…) { this.applyLanguage(initialLanguage); } }]— na inicialização: se o usuário já havia selecionado um idioma em uma visita anterior, ele é restaurado; caso contrário, usa-se o francês se o navegador estiver em francês, senão mantém-se o idioma padrão definido em app.config.ts (inglês);
  • linhas 21–24: [changeLanguage(language: Language): void { localStorage.setItem(…); this.applyLanguage(language); }] — chamado pelos dois botões FR/EN da barra de navegação (veja [app.html]);
  • linhas 26–30: [private applyLanguage(language: Language): void { this.translate.use(language).subscribe(() => { document.documentElement.lang = language; }); }] — translate.use(language) carrega (se necessário) o arquivo public/i18n/<language>.json correspondente e depois troca o idioma atual; trata-se de um Observable que emite um sinal quando o carregamento termina — aproveitamos para atualizar o atributo <html lang="..."> da página (útil para acessibilidade), que o [Angular] não gerencia por conta própria, já que index.html é uma página estática carregada antes mesmo de a aplicação iniciar.

Equivalente ao botão “FR / EN” do cliente AngularJS 1.x original, que na época se apoiava na biblioteca angular-translate — a antecessora, dentro do ecossistema AngularJS 1.x, do ngx-translate usado aqui.

6.7. Dicionários de tradução (public/i18n/)

O TranslateHttpLoader ([@ngx-translate/http-loader], configurado em app.config.ts abaixo) carrega um desses dois arquivos por meio de uma requisição HTTP GET [/i18n/]<language>.json, sempre que o idioma muda (ou é usado pela primeira vez). O [TranslateService] então achata esse JSON em um dicionário "LOGIN.TITLE", "SCHEDULE.FREE"…, que é consultado pelo pipe | translate usado em todos os templates do diretório features/ (veja mais adiante neste capítulo).

Image

6.7.1. public/i18n/fr.json

{
  "APP": {
    "TITLE": "RdvMedecins - portage NestJS / Angular",
    "SERVER_URL_LABEL": "URL du serveur",
    "LOGOUT": "Se déconnecter"
  },
  "LOGIN": {
    "TITLE": "Connexion",
    "LOGIN_LABEL": "Login",
    "PASSWORD_LABEL": "Mot de passe",
    "SUBMIT": "Se connecter",
    "SUBMITTING": "Connexion...",
    "ERROR": "Login ou mot de passe incorrect.",
    "DEMO_ACCOUNTS_PREFIX": "Comptes de démonstration :",
    "DEMO_ACCOUNTS_ADMIN": "(rôle ADMIN, accès complet)",
    "DEMO_ACCOUNTS_OR": "ou",
    "DEMO_ACCOUNTS_USER": "(rôle USER, lecture seule)"
  },
  "DOCTOR_DAY_PICKER": {
    "DOCTOR_LABEL": "Médecin",
    "CHOOSE_DOCTOR": "-- choisir un médecin --",
    "DAY_LABEL": "Jour",
    "VIEW_SCHEDULE": "Voir l'agenda"
  },
  "SCHEDULE": {
    "TITLE_PREFIX": "Agenda du",
    "COLUMN_SLOT": "Créneau",
    "COLUMN_STATUS": "Statut",
    "FREE": "Libre",
    "BOOK": "Réserver",
    "CANCEL_APPOINTMENT": "Annuler",
    "EMPTY_STATE": "Choisissez un médecin et un jour, puis cliquez sur « Voir l'agenda »."
  },
  "BOOKING_DIALOG": {
    "TITLE": "Réserver ce créneau",
    "CLOSE_ARIA": "Fermer",
    "SLOT_FROM": "Créneau de",
    "SLOT_TO": "à",
    "PATIENT_LABEL": "Patient",
    "CHOOSE_PATIENT": "-- choisir un patient --",
    "CANCEL": "Annuler",
    "CONFIRM": "Confirmer"
  }
}

Vamos comentar este código:

  • linha 1: [{] — um objeto JSON aninhado, uma seção por componente (APP, LOGIN, DOCTOR_DAY_PICKER, SCHEDULE, BOOKING_DIALOG); o [TranslateService] o achata em um dicionário plano, em que cada chave completa ("LOGIN.TITLE") é formada pela junção do caminho com pontos;
  • linhas 14–17: [“DEMO_ACCOUNTS_PREFIX” / “DEMO_ACCOUNTS_ADMIN” / “DEMO_ACCOUNTS_OR” / “DEMO_ACCOUNTS_USER”] — uma frase dividida em quatro chaves em vez de uma só: o texto completo do documento original (“Contas de demonstração: admin / admin (papel ADMIN…) ou user / user (papel USER…)”) também contém elementos <code>admin</code> que não devem ser traduzidos (são credenciais de login, idênticas nos dois idiomas) — eles precisam, portanto, ser inseridos entre fragmentos traduzidos (veja login.component.html abaixo);
  • linha 32: [“EMPTY_STATE”: “Choisissez un médecin et un jour, puis cliquez sur « Voir l’agenda ».”] — ao contrário da maioria das outras chaves (que são simples rótulos), esta é uma frase completa: nada impede que uma chave de tradução contenha pontuação ou várias palavras, desde que corresponda a um único bloco de texto no template.

6.7.2. public/i18n/en.json

  {
    "APP": {
      "TITLE": "RdvMedecins - NestJS / Angular port",
      "SERVER_URL_LABEL": "Server URL",
      "LOGOUT": "Log out"
    },
    "LOGIN": {
      "TITLE": "Login",
      "LOGIN_LABEL": "Login",
     "PASSWORD_LABEL": "Password",
     "SUBMIT": "Log in",
     "SUBMITTING": "Signing in...",
     "ERROR": "Incorrect login or password.",
     "DEMO_ACCOUNTS_PREFIX": "Demo accounts:",
     "DEMO_ACCOUNTS_ADMIN": "(ADMIN role, full access)",
     "DEMO_ACCOUNTS_OR": "or",
     "DEMO_ACCOUNTS_USER": "(USER role, read-only)"
   },
   "DOCTOR_DAY_PICKER": {
     "DOCTOR_LABEL": "Doctor",
     "CHOOSE_DOCTOR": "-- choose a doctor --",
     "DAY_LABEL": "Day",
     "VIEW_SCHEDULE": "View schedule"
   },
   "SCHEDULE": {
     "TITLE_PREFIX": "Schedule for",
     "COLUMN_SLOT": "Slot",
     "COLUMN_STATUS": "Status",
     "FREE": "Free",
     "BOOK": "Book",
     "CANCEL_APPOINTMENT": "Cancel",
     "EMPTY_STATE": "Choose a doctor and a day, then click "View schedule"."
   },
   "BOOKING_DIALOG": {
     "TITLE": "Book this slot",
     "CLOSE_ARIA": "Close",
     "SLOT_FROM": "Slot from",
     "SLOT_TO": "to",
     "PATIENT_LABEL": "Patient",
     "CHOOSE_PATIENT": "-- choose a patient --",
     "CANCEL": "Cancel",
     "CONFIRM": "Confirm"
   }
 }

Vamos detalhar este código:

  • linha 3: [“TITLE”: “RdvMedecins - NestJS / Angular port”,] — apenas o subtítulo muda: “[RdvMedecins]” permanece igual nos dois idiomas; é o nome próprio da aplicação;
  • linha 11: [“SUBMIT”: “Log in”,] — tradução adaptada em vez de literal (“Connect” teria sido uma tradução direta do francês): a terminologia padrão de autenticação em inglês distingue “log in” (verbo, a ação de entrar) de “login” (substantivo, o nome de usuário digitado — veja a linha 9, que permanece “[Login]” nos dois idiomas, pois também é o nome do campo esperado pelo servidor; veja [LoginDto] no Capítulo 3).

Os dois arquivos devem permanecer estruturalmente idênticos (as mesmas chaves nos dois): isso garante que uma chave exista nos dois idiomas. Uma chave ausente de um dos dois arquivos seria exibida como está (seu nome bruto) em vez de sua tradução, até ser adicionada.

O que não é traduzido: as mensagens de erro retornadas pelo servidor (veja o Capítulo 3, envelope [ServerResponse]<T>) permanecem em inglês, qualquer que seja o idioma selecionado no lado do cliente — traduzir essas mensagens exigiria internacionalização no lado do servidor, o que está fora do escopo desta etapa (veja o Capítulo 6, Conclusão). Os nomes de médicos e pacientes, por outro lado, vêm diretamente do banco de dados e, naturalmente, não são traduzidos em nenhum dos dois casos.

6.8. A camada core/interceptors

Image

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

Um interceptor HTTP é inserido entre o [HttpClient] e a rede: ele intercepta toda requisição de saída (e sua resposta) e pode modificá-las. É o equivalente moderno dos interceptors do $http do AngularJS 1.x já discutidos no documento original (capítulo “Exemplo 6”) - A forma mudou (uma simples função em vez de um objeto com métodos request/response), mas a ideia continua a mesma.

  import { inject } from '@angular/core';
  import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
  import { catchError, throwError } from 'rxjs';
  import { AuthService } from '../services/auth.service';

  export const authInterceptor: HttpInterceptorFn = (request, next) => {
    const auth = inject(AuthService);
    const token = auth.accessToken();

   const requestWithToken = token
     ? request.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
     : request;

   return next(requestWithToken).pipe(
     catchError((error: unknown) => {
       if (error instanceof HttpErrorResponse && error.status === 401) {
         auth.logOut();
       }
       return throwError(() => error);
     }),
   );
 };

Vamos comentar este código:

  • Linha 6: [export const authInterceptor: HttpInterceptorFn = (request, next) => {] — Há algumas versões, o [Angular] privilegia os interceptors funcionais ([HttpInterceptorFn]) — uma simples função — em vez dos interceptors baseados em classes das versões anteriores do [Angular]: mais curtos de escrever e mais simples de registrar (veja app.config.ts, withInterceptors([...]));
  • linhas 10–12: [request.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : request;] — uma requisição do [HttpClient] é um objeto imutável — não é possível modificar seus cabeçalhos diretamente; é preciso criar uma cópia modificada. É essa cópia (requestWithToken) que deve ser repassada pela cadeia, nunca a requisição original, não modificada;
  • linhas 15–18: [catchError((error) => { if (error instanceof HttpErrorResponse && error.status === 401) { auth.logOut(); } … })] — um erro 401 durante uma sessão significa que o token não é mais válido (expirou, ou o servidor foi reiniciado): o cliente é desconectado de forma adequada, em vez de ser deixado em um estado inconsistente (aparentemente conectado, mas sem que nenhuma requisição tenha êxito);
  • linha 19: [return throwError(() => error);] — o erro é relançado como está após esse tratamento: o interceptor não deve ocultar o erro do código chamador ([ScheduleComponent] via [App], por exemplo), mas apenas tratar um caso específico de passagem.

Poderíamos adicionar manualmente Authorization: Bearer ... a cada um dos métodos de AppointmentService. Um interceptor evita essa repetição: a pergunta “Como autenticamos uma requisição?” é respondida em um único lugar, de uma vez por todas, e passará a valer automaticamente para qualquer serviço futuro que use HttpClient. Ele é registrado em app.config.ts (abaixo), por meio de provideHttpClient(withInterceptors([authInterceptor])): sem essa linha, a função existiria, mas nunca seria chamada.

6.9. Configuração da aplicação

Image

6.9.1. src/app/app.config.ts

  import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
  import { provideHttpClient, withInterceptors } from '@angular/common/http';
  import { provideRouter } from '@angular/router';
  import { provideTranslateService } from '@ngx-translate/core';
  import { provideTranslateHttpLoader } from '@ngx-translate/http-loader';
  import { routes } from './app.routes';
  import { authInterceptor } from './core/interceptors/auth.interceptor';

  export const appConfig: ApplicationConfig = {
   providers: [
     provideBrowserGlobalErrorListeners(),
     provideRouter(routes),
     provideHttpClient(withInterceptors([authInterceptor])),
     provideTranslateService({
       lang: 'en',
       fallbackLang: 'en',
       loader: provideTranslateHttpLoader({ prefix: '/i18n/', suffix: '.json' }),
     }),
   ],
 };

Vamos comentar este código:

  • Linha 9: [export const appConfig: ApplicationConfig = {] — o que o componente raiz ([App]) recebe para funcionar. É um conceito específico das aplicações [Angular] “standalone” (sem NgModule): cada provideXxx() ativa um serviço transversal à aplicação; não há equivalente direto deste arquivo no projeto AngularJS 1.x original;
  • Linha 12: [provideRouter(routes),] — ativa o roteador do Angular. Nossa aplicação tem apenas uma página: é um componente ([LoginComponent]), exibido condicionalmente pelo [App], que serve como tela de login — e não uma rota dedicada (veja app.routes.ts abaixo) ;
  • linha 13: [provideHttpClient(withInterceptors([authInterceptor])),] — ativa o [HttpClient], usado pelo [AppointmentService] e pelo [AuthService] - o equivalente moderno do serviço $http do AngularJS 1.x. withInterceptors ([authInterceptor]) registra o interceptor de autenticação: sem essa linha, authInterceptor existiria, mas nunca seria chamado;
  • linhas 14–18: [provideTranslateService({ lang: ‘en’, fallbackLang: ‘en’, loader: provideTranslateHttpLoader({ prefix: ‘/i18n/’, suffix: ‘.json’ }), }),] — ativa o [@ngx-translate/core], a biblioteca usada para alternar a interface entre francês e inglês. lang: 'en' define o idioma de inicialização ([LanguageService], veja acima, o substituirá imediatamente pela seleção armazenada em localStorage, se existir, ou pelo francês, se o navegador estiver em francês); fallbackLang: 'en' seria usado se uma chave de tradução estivesse ausente do dicionário do idioma atual; loader: provideTranslateHttpLoader(...) indica COMO carregar os dicionários — aqui, por meio de uma requisição HTTP GET a arquivos JSON estáticos (public/i18n/fr.json, public/i18n/en.json, veja acima), com o prefixo e o sufixo formando a URL completa (prefixo + idioma + sufixo, por exemplo, /i18n/en.json).

6.9.2. src/app/app.routes.ts

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

export const routes: Routes = [];

Vamos comentar este código:

  • linha 3: [export const routes: Routes = [];] — a tabela de rotas permanece vazia: a aplicação cabe em uma única página (o componente raiz [App] exibe a tela de login ou o seletor de médico/dia + o calendário + a janela de agendamento, conforme AuthService.isLoggedIn()). Poderíamos ter criado uma rota /login em vez de uma exibição condicional, mas, para uma aplicação de página única, esse desvio não teria utilidade.

6.10. A camada features: os quatro componentes

Image

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

A tela de login: equivalente à view [login.html] do cliente AngularJS 1.x original (a primeira view exibida pela aplicação).

  import { Component, DestroyRef, inject, signal } from '@angular/core';
  import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
  import { TranslatePipe } from '@ngx-translate/core';
  import { AuthService } from '../../core/services/auth.service';

  @Component({
    selector: 'app-login',
    imports: [TranslatePipe],
    templateUrl: './login.component.html',
   styleUrl: './login.component.css',
 })
 export class LoginComponent {
   private readonly auth = inject(AuthService);
   private readonly destroyRef = inject(DestroyRef);

   protected readonly login = signal('');
   protected readonly password = signal('');

   protected readonly inProgress = signal(false);
   protected readonly error = signal<string | null>(null);

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

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

   onSubmit(): void {
     if (this.login().trim() === '' || this.password() === '') {
       return;
     }
     this.error.set(null);
     this.inProgress.set(true);
     this.auth
       .logIn(this.login(), this.password())
       .pipe(takeUntilDestroyed(this.destroyRef))
       .subscribe({
         next: () => this.inProgress.set(false),
         error: () => {
           this.inProgress.set(false);
           this.error.set('LOGIN.ERROR');
         },
       });
   }
 }

Vamos comentar este código:

  • linha 8: [imports: [TranslatePipe],] — um componente standalone declara os pipes que usa em seu template; o [TranslatePipe] ([@ngx-translate/core]) é o que torna | translate disponível em login.component.html (abaixo);
  • Linhas 16–17: [protected readonly login = signal(’‘); protected readonly password = signal(’’);] — estado puramente local do formulário (o que o usuário está digitando no momento);
  • linha 19: [protected readonly inProgress = signal(false);] — true durante a chamada de rede: desabilita o botão para evitar um clique duplo;
  • linha 20: [protected readonly error = signal<string | null>(null);] — armazena uma chave de tradução, e não um texto já traduzido: o pipe | translate no template a resolve no momento da exibição;
  • linha 30: [onSubmit(): void {] — acionado pelo botão “Log in” (veja o template abaixo);
  • linha 40: [next: () => this.inProgress.set(false),] — nenhum processamento adicional é necessário aqui: o [AuthService] já armazenou a sessão (signal + localStorage) — é o [App], que lê auth.isLoggedIn(), que reagirá deixando de exibir <app-login>;
  • Linhas 41–44: [error: () => { …this.error.set(‘LOGIN.ERROR’); }] — uma combinação inválida de nome de usuário/senha faz logIn() falhar com erro HTTP 401 (veja o Capítulo 3, [LocalStrategy]): o usuário vê simplesmente 'LOGIN.ERROR' (“Incorrect login or password.” / “Login ou mot de passe incorrect.”, dependendo do idioma), sem qualquer tentativa de distinguir entre um nome de usuário inexistente e uma senha incorreta (por precaução, como faria qualquer aplicação real). Armazenar uma chave em vez de texto simples tem uma vantagem prática: se o usuário trocar de idioma enquanto essa mensagem estiver exibida, ela se traduz sozinha, sem exigir nenhum código adicional aqui.

6.10.2. src/app/features/login/login.component.html

  <div class="row justify-content-center">
    <div class="col-sm-8 col-md-6 col-lg-4">
      <div class="card p-4">
        <h5 class="card-title mb-3">{{ 'LOGIN.TITLE' | translate }}</h5>

        @if (error(); as errorMessage) {
          <div class="alert alert-danger py-2" role="alert">{{ errorMessage | translate }}</div>
        }

       <div class="mb-3">
         <label class="form-label" for="input-login">{{ 'LOGIN.LOGIN_LABEL' | translate }}</label>
         <input id="input-login" type="text" class="form-control" autocomplete="username"
                [value]="login()" (input)="onLoginChange($event)" (keyup.enter)="onSubmit()">
       </div>

       <div class="mb-3">
         <label class="form-label" for="input-password">{{ 'LOGIN.PASSWORD_LABEL' | translate }}</label>
         <input id="input-password" type="password" class="form-control" autocomplete="current-password"
                [value]="password()" (input)="onPasswordChange($event)" (keyup.enter)="onSubmit()">
       </div>

       <button type="button" class="btn btn-primary w-100" [disabled]="inProgress()" (click)="onSubmit()">
         @if (inProgress()) { {{ 'LOGIN.SUBMITTING' | translate }} } @else { {{ 'LOGIN.SUBMIT' | translate }} }
       </button>

       <p class="text-muted small mt-3 mb-0">
         {{ 'LOGIN.DEMO_ACCOUNTS_PREFIX' | translate }} <code>admin</code> / <code>admin</code> {{ 'LOGIN.DEMO_ACCOUNTS_ADMIN' | translate }}
         {{ 'LOGIN.DEMO_ACCOUNTS_OR' | translate }} <code>user</code> / <code>user</code> {{ 'LOGIN.DEMO_ACCOUNTS_USER' | translate }}.
       </p>
     </div>
   </div>
 </div>

Vamos detalhar este código:

  • linhas 1–2: [] — classes de grid do Bootstrap: centraliza horizontalmente um card de largura fixa, independentemente da largura da tela;
  • linhas 12–13, 18–19: [(input)=“onLoginChange($event)” (keyup.enter)=“onSubmit()”] — sem FormsModule/ngModel: os campos são lidos diretamente pelo evento (input) do DOM, e (keyup.enter) permite enviar o formulário pelo teclado, sem usar o mouse;
  • linha 22: [[disabled]=“inProgress()”] — o botão fica desabilitado durante a chamada de rede (veja LoginComponent.inProgress) para evitar um clique duplo enquanto a primeira tentativa ainda está em andamento;
  • linhas 27–28: [{{ ‘LOGIN.DEMO_ACCOUNTS_PREFIX’ | translate }} admin / admin {{ ‘LOGIN.DEMO_ACCOUNTS_ADMIN’ | translate }} …] — o texto das contas de demonstração alterna entre texto traduzido e identificadores não traduzidos (<code>admin</code>, <code>user</code>): para permitir essa mistura, a frase foi dividida em quatro chaves separadas nos dicionários JSON (veja acima, public/i18n/fr.json), em vez de uma única chave contendo a frase inteira.

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

O componente que permite selecionar um médico e uma data e, em seguida, ver a agenda dele. Conceitualmente equivalente aos exemplos 7 a 10 do cliente AngularJS 1.x original.

  import { Component, input, output, signal } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { Doctor } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-doctor-day-picker',
    imports: [TranslatePipe],
    templateUrl: './doctor-day-picker.component.html',
    styleUrl: './doctor-day-picker.component.css',
 })
 export class DoctorDayPickerComponent {
   readonly doctors = input.required<Doctor[]>();
   readonly search = output<{ doctorId: number; day: string }>();

   readonly selectedDoctorId = signal<number | null>(null);
   readonly selectedDay = signal<string>(new Date().toISOString().slice(0, 10));

   onDoctorChange(event: Event): void {
     const value = (event.target as HTMLSelectElement).value;
     this.selectedDoctorId.set(value === '' ? null : Number(value));
   }

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

   onSearchClick(): void {
     const doctorId = this.selectedDoctorId();
     if (doctorId === null) {
       return;
     }
     this.search.emit({ doctorId, day: this.selectedDay() });
   }
 }

Vamos analisar este código:

  • linha 7: [imports: [TranslatePipe],] — torna | translate disponível em doctor-day-picker.component.html (abaixo);
  • linha 12: [readonly doctors = input.required<Doctor[]>();] — declara que este componente deve receber a lista de médicos do componente pai ([App]) — o [Angular] relata um erro se este componente for usado sem que essa entrada seja fornecida. input() (baseado em signals) substitui a palavra-chave legada @Input(): [doctors]() é tratado como uma função, o que permite ao [Angular] saber exatamente quando redesenhar o componente;
  • linha 13: [readonly search = output<{ doctorId: number; day: string }>();] — declara o evento que este componente propaga ao pai — equivalente a um evento personalizado ($emit/$broadcast) no AngularJS 1.x;
  • linhas 15–16: [selectedDoctorId / selectedDay] — um estado específico deste componente (o que está selecionado nos menus, enquanto o usuário não clicar no botão); selectedDay é inicializado com a data de hoje;
  • linhas 27–33: [onSearchClick(): void { … this.search.emit({ doctorId, day: … }); }] — não chama o HTTP por conta própria: apenas repassa ao pai a intenção do usuário, e o pai decidirá se chama AppointmentService.

6.10.4. src/app/features/doctor-day-picker/doctor-day-picker.component.html

  <div class="card p-3 mb-3">
    <div class="row g-2 align-items-end">
      <div class="col-sm-5">
        <label class="form-label" for="select-doctor">{{ 'DOCTOR_DAY_PICKER.DOCTOR_LABEL' | translate }}</label>
        <select id="select-doctor" class="form-select" (change)="onDoctorChange($event)">
          <option value="">{{ 'DOCTOR_DAY_PICKER.CHOOSE_DOCTOR' | translate }}</option>
          @for (doctor of doctors(); track doctor.id) {
            <option [value]="doctor.id">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</option>
          }
       </select>
     </div>
     <div class="col-sm-4">
       <label class="form-label" for="input-day">{{ 'DOCTOR_DAY_PICKER.DAY_LABEL' | translate }}</label>
       <input id="input-day" type="date" class="form-control" [value]="selectedDay()" (change)="onDayChange($event)">
     </div>
     <div class="col-sm-3">
       <button type="button" class="btn btn-primary w-100" [disabled]="selectedDoctorId() === null" (click)="onSearchClick()">
         {{ 'DOCTOR_DAY_PICKER.VIEW_SCHEDULE' | translate }}
       </button>
     </div>
   </div>
 </div>

Vamos analisar este código:

  • linha 7: [@for (doctor of doctors(); track doctor.id) {] — [@for] é a nova sintaxe de controle de fluxo do [Angular] (substitui *ngFor): repete um <option> para cada médico recebido do componente pai. track doctor.[id] informa ao [Angular] como reconhecer um médico já exibido caso ele seja redesenhado;
  • linha 17: [[disabled]=“selectedDoctorId() === null”] — o botão permanece desabilitado enquanto nenhum médico estiver selecionado, para evitar uma busca incompleta;
  • linhas 4, 6, 13, 18: [{{ ‘…’ | translate }}] — os quatro rótulos estáticos deste componente (“Doctor”, “-- choose a doctor --”, “Day”, “View schedule”), traduzidos por meio do pipe | translate (veja [LanguageService] acima). O nome de cada médico (linha 8), porém, vem diretamente dos dados do servidor e nunca é traduzido.

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

Exibe a agenda de um médico em determinado dia: uma lista de seus horários, cada um deles disponível (botão “Book”) ou reservado (nome do paciente + botão “Cancel”). Equivalente aos exemplos 8 e 9 do cliente AngularJS 1.x original.

  import { Component, input, output } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { DoctorDaySchedule, ScheduleSlot, SlotJson, AppointmentJson } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-schedule',
    imports: [TranslatePipe],
    templateUrl: './schedule.component.html',
    styleUrl: './schedule.component.css',
 })
 export class ScheduleComponent {
   readonly schedule = input<DoctorDaySchedule | null>(null);

   readonly canEdit = input<boolean>(true);

   readonly book = output<SlotJson>();
   readonly cancel = output<AppointmentJson>();

   formatTime(h: number, m: number): string {
     return `${h}:${m.toString().padStart(2, '0')}`;
   }

   onSlotClick(scheduleSlot: ScheduleSlot): void {
     if (!this.canEdit()) {
       return;
     }
     if (scheduleSlot.appointment === null) {
       this.book.emit(scheduleSlot.slot);
     } else {
       this.cancel.emit(scheduleSlot.appointment);
     }
   }
 }

Vamos comentar este código:

  • linha 12: [readonly schedule = input<DoctorDaySchedule | null>(null);] — `input()` sem `.required` permite um valor padrão (aqui, `null`): ele é `null` até que uma busca seja realizada;
  • linha 14: [readonly canEdit = input<boolean>(true);] — uma novidade introduzida pela autenticação: true por padrão (papel ADMIN); [App] passa auth.isAdmin() para ele (veja [app.html]). Quando definido como false (papel USER), os botões “Book”/“Cancel” desaparecem do template (veja abaixo) — a agenda continua visível, mas em modo somente leitura;
  • linhas 23–26: [onSlotClick(scheduleSlot: ScheduleSlot): void { if (!this.canEdit()) { return; } … }] — este guard da aplicação é redundante com o botão oculto no template (um papel USER nunca vê esse botão): ainda assim, ele protege contra uma chamada programática a este método e documenta a intenção no mesmo lugar que o restante da lógica. Lembrete: em todo caso, o servidor ([RolesGuard], Capítulo 3) continua sendo a única salvaguarda real — um cliente [Angular] modificado manualmente não poderia contornar essa restrição;
  • Linhas 27–31: [if (scheduleSlot.appointment === null) { this.book.emit(…); } else { this.cancel.emit(…); }] — se o horário está disponível, o usuário é convidado a reservá-lo; se o horário já está reservado, o usuário é convidado a cancelar a consulta existente. Este componente não faz nenhuma chamada HTTP por conta própria: ele exibe os dados recebidos e notifica o pai das intenções do usuário.

6.10.6. src/app/features/schedule/schedule.component.html

  @if (schedule(); as currentSchedule) {
    <div class="card p-3">
      <h5>{{ 'SCHEDULE.TITLE_PREFIX' | translate }} {{ currentSchedule.day }} - {{ currentSchedule.doctor.title }} {{ currentSchedule.doctor.firstName }} {{ currentSchedule.doctor.lastName }}</h5>

      <table class="table table-hover align-middle">
        <thead>
          <tr><th>{{ 'SCHEDULE.COLUMN_SLOT' | translate }}</th><th>{{ 'SCHEDULE.COLUMN_STATUS' | translate }}</th><th></th></tr>
        </thead>
        <tbody>
         @for (scheduleSlot of currentSchedule.slots; track scheduleSlot.slot.id) {
           <tr [class.free-slot]="scheduleSlot.appointment === null">
             <td>{{ formatTime(scheduleSlot.slot.startHour, scheduleSlot.slot.startMinute) }} - {{ formatTime(scheduleSlot.slot.endHour, scheduleSlot.slot.endMinute) }}</td>
             <td>
               @if (scheduleSlot.appointment === null) {
                 <span class="badge text-bg-success">{{ 'SCHEDULE.FREE' | translate }}</span>
               } @else {
                 <span class="badge text-bg-secondary">{{ scheduleSlot.appointment.client?.title }} {{ scheduleSlot.appointment.client?.firstName }} {{ scheduleSlot.appointment.client?.lastName }}</span>
               }
             </td>
             <td>
               @if (canEdit()) {
                 <button type="button" class="btn btn-sm" [class.btn-outline-success]="scheduleSlot.appointment === null"
                         [class.btn-outline-danger]="scheduleSlot.appointment !== null" (click)="onSlotClick(scheduleSlot)">
                   {{ scheduleSlot.appointment === null ? ('SCHEDULE.BOOK' | translate) : ('SCHEDULE.CANCEL_APPOINTMENT' | translate) }}
                 </button>
               }
             </td>
           </tr>
         }
       </tbody>
     </table>
   </div>
 } @else {
   <p class="text-muted">{{ 'SCHEDULE.EMPTY_STATE' | translate }}</p>
 }

Vamos comentar este código:

  • linha 1: [@if (schedule(); as currentSchedule) {] — @if e @for são a nova sintaxe de controle de fluxo do [Angular]: substituem *ngIf e *ngFor, respectivamente, e fazem parte da própria linguagem de template (sem necessidade de importar módulo). as currentSchedule captura o valor não nulo em uma variável de template, evitando repetir `schedule()!` em todos os lugares depois;
  • linhas 14–18: [@if (scheduleSlot.appointment === null) { ... } @else { ... }] — badge verde do Bootstrap (“Free”/“Libre”) ou cinza (nome do paciente), dependendo da situação do horário;
  • linha 21: [@if (canEdit()) {] — uma novidade introduzida pela autenticação: o botão “Book”/“Cancel” nem sequer existe no DOM para o papel USER (canEdit() é então false) — ele não está apenas esmaecido ou desabilitado, está completamente ausente;
  • linha 24: [{{ scheduleSlot.appointment === null ? (‘SCHEDULE.BOOK’ | translate) : (‘SCHEDULE.CANCEL_APPOINTMENT’ | translate) }}] — um pipe pode ser usado dentro de qualquer expressão de template, inclusive um operador ternário, desde que cada ramo esteja corretamente entre parênteses.

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

A janela (modal) que permite selecionar um paciente para reservar um horário disponível. Equivalente ao exemplo 9 do cliente AngularJS 1.x original.

  import { Component, input, output, signal } from '@angular/core';
  import { TranslatePipe } from '@ngx-translate/core';
  import { Client, SlotJson } from '../../core/models/appointment.models';

  @Component({
    selector: 'app-booking-dialog',
    imports: [TranslatePipe],
    templateUrl: './booking-dialog.component.html',
    styleUrl: './booking-dialog.component.css',
 })
 export class BookingDialogComponent {
   readonly open = input.required<boolean>();
   readonly slot = input<SlotJson | null>(null);
   readonly clients = input.required<Client[]>();

   readonly confirm = output<{ clientId: number }>();
   readonly close = output<void>();

   readonly selectedClientId = signal<number | null>(null);

   onClientChange(event: Event): void {
     const value = (event.target as HTMLSelectElement).value;
     this.selectedClientId.set(value === '' ? null : Number(value));
   }

   onConfirmClick(): void {
     const clientId = this.selectedClientId();
     if (clientId === null) {
       return;
     }
     this.confirm.emit({ clientId });
     this.selectedClientId.set(null);
   }

   onCloseClick(): void {
     this.selectedClientId.set(null);
     this.close.emit();
   }
 }

Vamos comentar este código:

  • linha 12: [readonly open = input.required<boolean>();] — o componente está sempre presente no template do pai ([App]): esta entrada controla, por meio de [@if] (veja o template abaixo), se ele é exibido ou não;
  • Linhas 26–33: [onConfirmClick(): void { … this.confirm.emit({ clientId }); this.selectedClientId.set(null); }] — passa o ID do paciente selecionado para [App], que então chamará AppointmentService.addAppointment(...); selectedClientId é redefinido para a próxima vez que a janela for aberta;
  • linhas 35–38: [onCloseClick(): void { … this.close.emit(); }] — se o usuário cancela, o pai simplesmente fecha a janela sem fazer uma chamada ao servidor.

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

Este componente agora usa as verdadeiras classes do Bootstrap para um modal (.modal, .modal-dialog, .modal-content, .modal-backdrop…), mas sua visibilidade ainda é controlada pelo [Angular] ([@if] (open())) e não pelo JavaScript do Bootstrap (bootstrap.bundle.js, new bootstrap.Modal(...)).

  @if (open()) {
    <div class="modal-backdrop fade show"></div>

    <div class="modal fade show d-block" tabindex="-1" role="dialog" aria-modal="true">
      <div class="modal-dialog modal-dialog-centered">
        <div class="modal-content">
          <div class="modal-header">
            <h5 class="modal-title">{{ 'BOOKING_DIALOG.TITLE' | translate }}</h5>
            <button type="button" class="btn-close" [attr.aria-label]="'BOOKING_DIALOG.CLOSE_ARIA' | translate" (click)="onCloseClick()"></button>
         </div>

         <div class="modal-body">
           @if (slot(); as currentSlot) {
             <p>{{ 'BOOKING_DIALOG.SLOT_FROM' | translate }} {{ currentSlot.startHour }}:{{ currentSlot.startMinute.toString().padStart(2, '0') }}
                {{ 'BOOKING_DIALOG.SLOT_TO' | translate }} {{ currentSlot.endHour }}:{{ currentSlot.endMinute.toString().padStart(2, '0') }}</p>
           }
           <label class="form-label" for="select-client">{{ 'BOOKING_DIALOG.PATIENT_LABEL' | translate }}</label>
           <select id="select-client" class="form-select" (change)="onClientChange($event)">
             <option value="">{{ 'BOOKING_DIALOG.CHOOSE_PATIENT' | translate }}</option>
             @for (client of clients(); track client.id) {
               <option [value]="client.id">{{ client.title }} {{ client.firstName }} {{ client.lastName }}</option>
             }
           </select>
         </div>

         <div class="modal-footer">
           <button type="button" class="btn btn-secondary" (click)="onCloseClick()">{{ 'BOOKING_DIALOG.CANCEL' | translate }}</button>
           <button type="button" class="btn btn-primary" [disabled]="selectedClientId() === null" (click)="onConfirmClick()">
             {{ 'BOOKING_DIALOG.CONFIRM' | translate }}
           </button>
         </div>
       </div>
     </div>
   </div>
 }

Vamos analisar este código:

  • linha 2: [] — o fundo semitransparente que escurece o restante da página — escrito diretamente aqui, enquanto o Bootstrap normalmente o insere por conta própria via JavaScript quando o modal é exibido;
  • linha 4: [<div class=“modal fade show d-block” …>] — d-block assume o papel normalmente desempenhado pelo JavaScript do Bootstrap (adicionar `display:block` na abertura) — aqui, é o [@if] da linha 1 que cumpre diretamente esse papel;
  • linhas 6–10, 12–24, 26–31: [.modal-content / .modal-header / .modal-body / .modal-footer] — a estrutura padrão de um modal do Bootstrap (cabeçalho com título + botão de fechar, corpo, rodapé com ações);
  • linha 9: [[attr.aria-label]=“‘BOOKING_DIALOG.CLOSE_ARIA’ | translate”] — o botão de fechar padrão do Bootstrap (.btn-close), vinculado ao mesmo manipulador de evento do botão “Cancel” no rodapé do modal (linha 27); seu texto acessível (aria-label) é definido por meio de um binding de atributo ([attr.xxx]) e não pela simples interpolação {{ }}, que é a única sintaxe possível quando o valor de um atributo HTML não é um texto estático.

Por que não usar o JavaScript do Bootstrap? Porque o Bootstrap e o [Angular] passariam a gerenciar, cada um por conta própria, a mesma informação (o modal está aberto?) — uma fonte clássica de bugs sutis em uma aplicação Angular. Ao deixar open() (um signal e, portanto, o estado [Angular]) controlar sozinho a exibição, temos uma única fonte de verdade, mantendo exatamente a aparência visual de um modal do Bootstrap. O documento original (2014) usava um componente da biblioteca angular-ui-bootstrap (um modal “pronto para uso” do AngularJS 1.x), já concebido segundo esse mesmo princípio: estado gerenciado pelo [Angular], aparência emprestada do Bootstrap.

6.11. O componente raiz [App]: orquestrador e guardião da autenticação

Este componente desempenha o papel do “controller principal” da aplicação AngularJS 1.x original: ele mantém o estado global da aplicação e responde aos eventos dos componentes de features/ para chamar [AppointmentService] no momento certo. Desde a adição da autenticação, ele assumiu um segundo papel: o de “porteiro” da camada de apresentação, que decide se exibe a tela de login ou o restante da aplicação.

Image

6.11.1. src/app/app.ts

  import { Component, DestroyRef, effect, inject, signal } from '@angular/core';
  import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
  import { TranslatePipe } from '@ngx-translate/core';
  import { AppointmentService } from './core/services/appointment.service';
  import { SettingsService } from './core/services/settings.service';
  import { AuthService } from './core/services/auth.service';
  import { LanguageService } from './core/services/language.service';
  // ... modelos, componentes (veja os imports detalhados do arquivo)

 @Component({
   selector: 'app-root',
   imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],
   templateUrl: './app.html',
   styleUrl: './app.css',
 })
 export class App {
   private readonly appointmentService = inject(AppointmentService);
   private readonly destroyRef = inject(DestroyRef);
   protected readonly settings = inject(SettingsService);
   protected readonly auth = inject(AuthService);
   protected readonly language = inject(LanguageService);

   protected readonly doctors = signal<Doctor[]>([]);
   protected readonly clients = signal<Client[]>([]);
   protected readonly schedule = signal<DoctorDaySchedule | null>(null);
   protected readonly error = signal<string | null>(null);
   protected readonly slotBeingBooked = signal<SlotJson | null>(null);

   private lastDoctorId: number | null = null;
   private lastDay: string | null = null;

   constructor() {
     effect(() => {
       if (this.auth.isLoggedIn()) {
         this.loadInitialLists();
       }
     });
   }

   private loadInitialLists(): void {
     this.appointmentService.getAllDoctors().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: (doctors) => this.doctors.set(doctors),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
     this.appointmentService.getAllClients().pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: (clients) => this.clients.set(clients),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
   }

   onLogout(): void {
     this.auth.logOut();
     this.doctors.set([]);
     this.clients.set([]);
     this.schedule.set(null);
     this.error.set(null);
     this.slotBeingBooked.set(null);
     this.lastDoctorId = null;
     this.lastDay = null;
   }

   onSearchSchedule(criteria: { doctorId: number; day: string }): void {
     this.error.set(null);
     this.lastDoctorId = criteria.doctorId;
     this.lastDay = criteria.day;
     this.loadSchedule();
   }

   onBookingRequest(slot: SlotJson): void {
     this.slotBeingBooked.set(slot);
   }

   onConfirmBooking(choice: { clientId: number }): void {
     const slot = this.slotBeingBooked();
     if (slot === null || this.lastDay === null) {
       return;
     }
     this.appointmentService.addAppointment(this.lastDay, choice.clientId, slot.id)
       .pipe(takeUntilDestroyed(this.destroyRef))
       .subscribe({
         next: () => { this.slotBeingBooked.set(null); this.loadSchedule(); },
         error: (err) => this.error.set(String(err.message ?? err)),
       });
   }

   onCloseBooking(): void {
     this.slotBeingBooked.set(null);
   }

   onCancelAppointment(appointment: AppointmentJson): void {
     this.appointmentService.deleteAppointment(appointment.id).pipe(takeUntilDestroyed(this.destroyRef)).subscribe({
       next: () => this.loadSchedule(),
       error: (err) => this.error.set(String(err.message ?? err)),
     });
   }

   private loadSchedule(): void {
     if (this.lastDoctorId === null || this.lastDay === null) {
       return;
     }
     this.appointmentService.getDoctorScheduleOfDay(this.lastDoctorId, this.lastDay)
       .pipe(takeUntilDestroyed(this.destroyRef))
      .subscribe({
        next: (schedule) => this.schedule.set(schedule),
        error: (err) => this.error.set(String(err.message ?? err)),
      });
  }
 }

Vamos comentar este código:

  • linha 12: [imports: [DoctorDayPickerComponent, ScheduleComponent, BookingDialogComponent, LoginComponent, TranslatePipe],] — um componente standalone declara os componentes e pipes que usa em seu template — [LoginComponent] foi adicionado a esta lista por causa da autenticação, e [TranslatePipe] por causa da tradução;
  • linha 20: [protected readonly auth = inject(AuthService);] — exposto ao template (protected, não private) para o badge de papel/nome e o botão de logout (veja [app.html]);
  • linha 21: [protected readonly language = inject(LanguageService);] — exposto ao template para os dois botões FR/EN na barra de navegação, que estão sempre visíveis (inclusive na tela de login), ao contrário do restante da interface;
  • Linha 33: [effect(() => { if (this.auth.isLoggedIn()) { this.loadInitialLists(); } });] — `effect()` executa novamente seu corpo toda vez que um signal que ele monitora muda — neste caso, isLoggedIn(). Ele também é executado uma vez imediatamente: se uma sessão já estava armazenada em localStorage (recarga da página), as listas são carregadas logo na inicialização, sem esperar um novo login;
  • linha 40: [private loadInitialLists(): void {] — quando um usuário passa a estar autenticado (login bem-sucedido ou sessão restaurada), as listas de médicos e clientes são carregadas de uma vez por todas — o equivalente, no lado do cliente, do que [ApplicationModelService] fazia quando o servidor era iniciado (Capítulo 3). Como todos os endpoints do servidor agora são protegidos por [JwtAuthGuard], seria inútil de qualquer forma (e causaria erros 401) fazer essa chamada antes do login;
  • linha 51: [onLogout(): void {] — responde ao botão “Log out”: limpa a sessão e todo o estado de negócio exibido (linhas 53–59) — sem isso, um novo usuário que fizesse login em seguida veria brevemente a agenda do usuário anterior;
  • Linhas 41, 45, etc.: [.pipe(takeUntilDestroyed(this.destroyRef))] — uma assinatura RxJS (.subscribe(...)) permanece ativa até ser explicitamente cancelada; este é um descuido comum e uma fonte de vazamentos de memória. Este operador cancela a assinatura automaticamente assim que o componente é destruído;
  • linha 69: [onBookingRequest(slot: SlotJson): void { this.slotBeingBooked.set(slot); }] — ainda não chama o servidor: apenas abre a janela de reserva. É onConfirmBooking (linha 73), acionado pelo evento (confirm) de [BookingDialogComponent], que de fato chama addAppointment;
  • Linhas 81, 92: [this.loadSchedule();] — após uma reserva ou cancelamento bem-sucedido, loadSchedule() é chamado novamente: isso permite que a agenda exibida reflita imediatamente o novo status, sem que o usuário precise atualizar a página.

6.11.2. src/app/app.html

  <div class="container py-4">
    <nav class="navbar navbar-expand-sm navbar-dark bg-primary rounded mb-4 px-3">
      <span class="navbar-brand mb-0">{{ 'APP.TITLE' | translate }}</span>

      <div class="d-flex align-items-center gap-2">
        <div class="btn-group btn-group-sm" role="group" aria-label="FR / EN">
          <button type="button" class="btn"
                  [class.btn-light]="language.currentLanguage() === 'fr'"
                  [class.btn-outline-light]="language.currentLanguage() !== 'fr'"
                 (click)="language.changeLanguage('fr')">FR</button>
         <button type="button" class="btn"
                 [class.btn-light]="language.currentLanguage() === 'en'"
                 [class.btn-outline-light]="language.currentLanguage() !== 'en'"
                 (click)="language.changeLanguage('en')">EN</button>
       </div>

       @if (auth.isLoggedIn()) {
         <span class="badge text-bg-light text-primary">{{ auth.role() }}</span>
         <span class="text-white">{{ auth.name() }}</span>
         <button type="button" class="btn btn-sm btn-outline-light" (click)="onLogout()">
           {{ 'APP.LOGOUT' | translate }}
         </button>
       }
     </div>
   </nav>

   <div class="row g-2 align-items-center mb-4">
     <div class="col-auto"><label class="form-label mb-0" for="input-server-url">{{ 'APP.SERVER_URL_LABEL' | translate }}</label></div>
     <div class="col-sm-4">
       <input id="input-server-url" type="text" class="form-control form-control-sm"
              [value]="settings.apiBaseUrl()" (change)="settings.setApiBaseUrl($any($event.target).value)">
     </div>
   </div>

   @if (error(); as errorMessage) {
     <div class="alert alert-danger" role="alert">{{ errorMessage }}</div>
   }

   @if (!auth.isLoggedIn()) {
     <app-login />
   } @else {
     <app-doctor-day-picker [doctors]="doctors()" (search)="onSearchSchedule($event)" />

     <app-schedule
       [schedule]="schedule()"
       [canEdit]="auth.isAdmin()"
       (book)="onBookingRequest($event)"
       (cancel)="onCancelAppointment($event)"
     />

     <app-booking-dialog
       [open]="slotBeingBooked() !== null"
       [slot]="slotBeingBooked()"
       [clients]="clients()"
       (confirm)="onConfirmBooking($event)"
       (close)="onCloseBooking()"
     />
   }
 </div>

Vamos analisar este código:

  • linha 2: [] — classes do Bootstrap para o cabeçalho de uma aplicação: um banner colorido (bg-primary), texto claro (navbar-dark) e alinhamento horizontal automático de seu conteúdo;
  • linha 3: [{{ ‘APP.TITLE’ | translate }}] — primeiro exemplo do pipe `translate` ([@ngx-translate/core]): em vez de um texto fixo em inglês, uma chave (APP.TITLE) resolvida no dicionário do idioma atual (public/i18n/fr.json ou en.json);
  • linhas 6–15: [<div class=“btn-group btn-group-sm” …> … FR … EN … ] — o seletor de idioma, sempre visível (antes e depois do login, ao contrário do badge de papel): dois botões do Bootstrap agrupados (btn-group), um dos quais fica destacado (btn-light em vez de btn-outline-light) conforme o idioma atual (language.currentLanguage()), e o clique em cada um chama language.changeLanguage('fr' | 'en');
  • linhas 17–23: [@if (auth.isLoggedIn()) { ... badge + name + logout button ... }] — este bloco aparece somente após o login; auth.[role]() preenche um badge do Bootstrap (text-bg-light badge), auth.[name]() exibe o nome do usuário, e o texto do botão também passa por | translate (chave APP.LOGOUT);
  • linha 28: [{{ ‘APP.SERVER_URL_LABEL’ | translate }}] — mesmo mecanismo do título, aplicado ao rótulo do campo “Server URL”;
  • linhas 27–33: [Server URL] — continua sendo exibido antes e depois do login (útil para apontar para outro servidor, [NestJS], mesmo antes de tentar fazer login);
  • linha 39: [@if (!auth.isLoggedIn()) { <app-login /> } @else { ... }] — o núcleo do papel de “plantão” de [App]: enquanto o usuário não estiver autenticado, nada além da tela de login é exibido — nem o seletor de médico/dia, nem a agenda, nem a janela de reserva;
  • linha 46: [[canEdit]=“auth.isAdmin()”] — repassa o controle a [ScheduleComponent] conforme o usuário autenticado tenha ou não o direito de reservar/cancelar (papel ADMIN) ou não (papel USER, somente leitura);
  • linhas 51–57: [<app-booking-dialog … />] — sempre presente no DOM (como antes da autenticação): sua visibilidade é controlada pela entrada open.

Observe que o seletor de idioma fica fora do bloco [@if] (auth.isLoggedIn()): ele precisa continuar utilizável desde a tela de login, antes de qualquer token JWT ser emitido — de fato, a captura de tela abaixo (“[Login] screen”) ilustra a mudança para o francês nesta mesma tela.

6.12. Guia passo a passo de uso da aplicação

As capturas de tela a seguir foram feitas durante a preparação deste documento, usando uma cópia de teste do servidor povoada com dados de demonstração (3 médicos, incluindo a Sra. Marie PELISSIER; 4 clientes, incluindo Brigitte BISTROU; e as duas contas admin/admin e user/user).

6.12.1. 1. Tela de login

Até que o usuário faça login, somente a tela de login é exibida — o restante da aplicação (seletor de médico/dia, agenda) ainda não aparece na página. Os dois botões “FR” e “EN” no cabeçalho, porém, já podem ser usados nesta etapa — nenhum token é necessário para mudar o idioma:

Image

Tela de login

Uma tentativa com senha incorreta exibe uma mensagem de erro sem mais detalhes (para evitar revelar se o problema está no nome de usuário ou na senha):

Image

Erro de login

Clicar em “FR” traduz a tela instantaneamente, inclusive esta mensagem de erro, caso ela esteja sendo exibida no momento da mudança de idioma — consequência direta da escolha explicada anteriormente neste capítulo (seção login.component.ts) de armazenar em error() uma chave de tradução em vez de um texto em inglês já resolvido:

Image

Tela de login em francês

6.12.2. 2. Login como administrador (papel ADMIN)

Depois de entrar com a conta admin/admin, o cabeçalho exibe o papel (badge “ADMIN”) e o nome do usuário, junto com um botão “Log out”. O seletor de médico/dia aparece, exatamente como antes da autenticação:

Image

Página inicial, após login como ADMIN

A interface em francês continua disponível após o login; ela então também traduz o badge do papel, os nomes dos rótulos e o botão "Log out":

Image

Página inicial, após login como ADMIN, em francês

Depois de selecionar um médico e clicar em “View schedule”, cada horário disponível tem um botão “Book” e cada horário reservado tem um botão “Cancel”: o papel ADMIN tem acesso total, exatamente como antes de os papéis serem adicionados:

Image

Agenda, visão ADMIN (botões Book/Cancel visíveis)

Clicar em “Book” abre a janela modal do Bootstrap, que pede para você selecionar um paciente:

Image

Janela de reserva (modal do Bootstrap)

Depois de selecionar um paciente e clicar em “Confirm”, a janela se fecha e a agenda é atualizada automaticamente: o horário reservado agora aparece como ocupado, com o nome do paciente selecionado:

Image

Agenda após a reserva

Clicar em “Cancel” (quando o horário está reservado) atualiza a agenda da mesma forma — o horário volta a “Free”:

Image

Agenda após o cancelamento

6.12.3. 3. Login como usuário (papel USER, somente leitura)

Depois de sair, fazer login com a conta user/user exibe um badge “USER” diferente:

Image

Tela inicial, após login como USER

A agenda continua visível, mas nenhum botão “Book”/“Cancel” aparece: a coluna de ações fica vazia para cada horário. Uma requisição direta ao servidor (por exemplo, usando o Postman e fornecendo o token do usuário) ainda receberia uma resposta 403 Forbidden — ocultar os botões é apenas uma conveniência de exibição; a restrição real é imposta por [RolesGuard] no lado do servidor (Capítulo 3):

Image

Agenda, visão USER (somente leitura, sem botões de ação)

6.13. O que fica fora do escopo ou adiado

O modo “debug” (exibição do template bruto da view atual) do cliente AngularJS 1.x original é um recurso deliberadamente omitido deste port — ele não aparecerá em uma etapa posterior do curso (veja o Capítulo 6, conclusão, para a justificativa dessa decisão). Já a definição de um atraso de rede artificial fica, de fato, adiada para uma etapa posterior.