11. Estudo de caso: o cliente Ionic da aplicação RdvMedecins
11.1. O problema
A aplicação [RdvMedecins] permite agendar consultas em um consultório médico. O curso de [NestJS] a escreveu como uma aplicação HTML, na qual o servidor gerava as páginas; os cursos de [Vue.js], [Angular] e [React] escreveram clientes web para ela, que geram as MESMAS páginas no navegador a partir dos dados JSON do servidor descritos no capítulo “O servidor RdvMedecins, uma caixa-preta”; o curso de [Flutter] desenvolveu um cliente mobile. Aqui, desenvolvemos o cliente [Ionic]: um aplicativo mobile ([Android]), construído com [Angular] e [Capacitor], que é TAMBÉM uma aplicação web, sem nenhuma modificação.
O cliente deve oferecer tudo o que os outros ofereciam:
- uma tela de login, protegida por um CAPTCHA, com a opção de criar uma conta de paciente;
- a agenda de um médico para um determinado dia, com reserva de consultas (janela de seleção do paciente) e cancelamento;
- para o administrador, o gerenciamento de médicos e clientes (listar, adicionar, editar, excluir);
- para o paciente, um painel pessoal (que mostra as consultas futuras, que ele pode cancelar) e o gerenciamento de sua conta;
- dois idiomas: francês e inglês;
- os mesmos endereços dos clientes web ([/schedule?doctorId=1&day=...]). No celular, eles são invisíveis, mas organizam o aplicativo; na web, os usuários podem recarregá-los, adicioná-los aos favoritos e navegar pelo aplicativo com os botões Voltar/Avançar do navegador.
Um aplicativo mobile traz suas próprias exigências: uma tela estreita (sem tabelas de cinco colunas), um teclado que esconde metade da tela, um botão Voltar, um gerenciador de senhas e requisições HTTP que não partem de uma página web servida pelo servidor (onde armazenar o cookie do token?).
É a oportunidade de reunir tudo o que os exemplos apresentaram separadamente: componentes e signals, formulários, o roteador e os guards, o estado compartilhado, as traduções e a comunicação com o servidor.
11.2. Instalação e execução
O servidor JSON deve estar instalado e em execução (veja o capítulo “O servidor RdvMedecins: uma caixa-preta”). O modo de teste do CAPTCHA não é necessário: você pode deixar o campo [CAPTCHA_TEST] em branco no arquivo [.env] do servidor.
Em uma janela de console aberta na pasta [rdvmedecins_ionic]:
- linha 1: baixa os pacotes do projeto (pasta [node_modules]), descritos pelo [package.json];
- linha 2: inicia o [ng serve], o servidor de desenvolvimento do [Angular], no endereço http://localhost:8100. Ele encaminha as requisições /api para o servidor JSON (arquivo [proxy.conf.json], como nos exemplos 22 a 25). Abra essa URL no [Chrome], de preferência com as ferramentas de desenvolvedor (F12) no modo “dispositivo móvel” (Ctrl+Shift+M), no tamanho de um celular.
Como nos exemplos, qualquer alteração em um arquivo-fonte é compilada e recarregada imediatamente no navegador.
Para testar no [Android] (requer o SDK do [Android] e o [Android Studio]; veja o capítulo “Configuração do ambiente de trabalho”):
| npx cap add android
npx ng build
npx cap sync android
npx cap run android
|
- Linha 1: uma única vez: cria o projeto [Android Studio] (pasta [android/]). Com o JDK de um [Android Studio] recente ([Java] 25), passamos então o projeto para o [Gradle] 9.1 (arquivo [android/gradle/wrapper/gradle-wrapper.properties], veja o exemplo 01);
- linha 2: compila a aplicação web em [dist/rdvmedecins_ionic/browser/];
- linha 3: copia-a para o projeto [Android];
- linha 4: executa-a no emulador ou em um celular conectado por USB (o comando pede que você escolha qual). O emulador se conecta ao servidor no endereço [10.0.2.2:8080] (veja o exemplo 22); para um celular real, informe o endereço do computador na rede Wi-Fi durante a compilação: [npx ng build --define "SERVER='http://192.168.1.20:8080'"] (veja [config.ts]). O capítulo “Implantação” detalha essas etapas.
As contas de demonstração estão listadas na tela de login (senha = login).
11.3. Usando a aplicação
As capturas de tela desta seção são de um celular com resolução de 1082 × 2342 pixels (412 × 892 pontos). Elas foram geradas pelo programa [captures/captures.mjs] (veja o exemplo 01), que controla um navegador [Chromium] nessa resolução e executa, para cada grupo de telas, um cenário da pasta [captures/scenarios/].
11.3.1. A tela de login
A tela de login; uma senha incorreta: a mensagem aparece na parte inferior da tela, e uma nova imagem é exibida (cada imagem só é usada uma vez):
11.3.2. A agenda, vista pelo administrador e pelos médicos
Conectado como [admin], você chega à agenda. O botão ☰ abre o menu: as telas acessíveis ao administrador e, no topo, quem está conectado:
Selecione um médico e uma data (a data em um calendário) e clique em “Ver agenda”. A URL muda para [/schedule?doctorId=1&day=2026-10-13]. Ao clicar em “Reservar”, a janela de reserva se abre; a URL muda para [/schedule?doctorId=1&day=2026-10-13&book=2]:
A consulta é salva; “Cancelar” pede confirmação:
Um médico vai diretamente para a SUA agenda do dia:

11.3.3. O painel do paciente
Um paciente ([martin]) acessa “Minha área”. Em uma agenda, ele vê “Reservado” ao lado dos horários de outros pacientes e marca uma consulta para si mesmo, sem selecionar um paciente específico:
Sua consulta aparece sob o seu nome; o botão “Reservar” deixa de estar disponível (apenas uma consulta futura). Na agenda de outro médico, onde sua consulta não aparece, uma mensagem explicaria por que ele não pode reservar. Sua área mostra a consulta:
“Gerenciar minha conta”: qualquer alteração exige a senha atual; os erros vêm do servidor:

O menu de um paciente não tem a entrada “Médicos”. Na web, se ele digitar o endereço /doctors por conta própria, o guard do roteador exibe uma página de erro 403 (veja [app.routes.ts]).
11.3.4. Gerenciamento de médicos e clientes
A lista de médicos; um cadastro preenchido incorretamente:
Uma inclusão bem-sucedida; um homônimo; a exclusão de um médico que tem consultas é negada:
11.3.5. Criação de uma conta
Na tela de login, digite o CAPTCHA e toque em “Criar uma conta de paciente”. O formulário é rejeitado pelo servidor; depois que a conta é criada, você volta à tela de login com as informações de login já preenchidas:
11.3.6. Em francês, em uma tela grande
O menu FR / EN na barra superior atualiza a tela localmente, sem fazer nenhuma requisição ao servidor, inclusive as datas (“mardi 13 octobre 2026”). Em uma tela larga (a web, um tablet), o menu permanece exibido à esquerda:


11.3.7. Sessão expirada
Se o token expirar (ou se o cookie for apagado), a requisição seguinte recebe uma resposta 401; a aplicação redireciona para a tela de login com uma mensagem:

11.4. Arquitetura do cliente
| rdvmedecins_ionic/
├── package.json the packages, the scripts
├── angular.json the Angular project configuration
├── tsconfig.json the TypeScript configuration
├── proxy.conf.json the development server (/api relay)
├── capacitor.config.ts the Capacitor configuration (Android)
├── android/ the Android Studio project (after npx cap add android)
├── captures/ the making of the screenshots (Playwright)
├── public/
│ └── i18n/ the dictionaries fr.json, en.json
└── src/
├── index.html the page that hosts the application
├── main.ts the startup
├── styles.scss the common styles
└── app/
├── app.ts the root component
├── back-button.ts Android's Back button
├── app.routes.ts the screens, their addresses, their access rights
├── config.ts the address of the server
├── formatting.ts the formatting of times and days
├── api/ the API access layer
├── i18n/ the languages
├── state/ session, messages, cache (signal-based services)
├── components/ the layout and the reusable components
└── pages/ the screens
|
Esta é a estrutura, arquivo por arquivo, do cliente [Flutter], com os nomes de arquivo do [Angular] (em minúsculas, com as palavras separadas por hifens):
- uma camada de dados ([api/]): a única que conhece o cliente HTTP do [Angular], as URLs e o formato JSON;
- uma camada de estado ([state/]): serviços baseados em signals, fornecidos para toda a aplicação por injeção de dependência, que as telas leem;
- uma camada de interface ([pages/], [components/]): componentes que exibem o estado e transmitem as ações do usuário.
A tabela a seguir compara o cliente [Flutter] com este cliente:
Conceito | Cliente Flutter | Cliente Ionic |
Telas | widgets | componentes do Angular e do Ionic |
os elementos que envolvem as telas | [layout.dart], o widget de uma [ShellRoute] | [layout.ts], envolvendo o [ion-router-outlet] |
o menu | [NavigationDrawer] / [NavigationRail] | [ion-menu] dentro de [ion-split-pane] |
os endereços | [go_router] | o roteador do Angular |
direitos de acesso | the [redirect] function of the router | um guard: [CanActivateFn] |
o cookie do token | um cliente HTTP que gerencia cookies | o navegador (web), [CapacitorHttp] (Android) |
a sessão expirada (401) | uma função atribuída ao [ApiClient] | um interceptor, [HttpInterceptorFn] |
o estado compartilhado | [ChangeNotifier] ([provider]) | serviços com signals ([inject()]) |
dados assíncronos | [FutureBuilder] | [resource()] |
dados já lidos | [Cache] (algumas linhas) | [Cache] (algumas linhas) |
o idioma armazenado | [shared_preferences] | [@capacitor/preferences] |
formulário rejeitado | erros abaixo dos campos | igual |
Todos os arquivos do cliente estão listados abaixo. Eles são amplamente comentados; esses comentários fazem parte do material do curso.
11.5. Configuração do projeto
O projeto foi criado da mesma forma que os exemplos (veja o exemplo 01): [ng new], seguido da adição dos pacotes [Ionic] e [Capacitor]. Os arquivos [angular.json] e [tsconfig.json] são os gerados pelo [ng new]; são idênticos aos dos exemplos, com duas exceções: no [angular.json], a porta do servidor de desenvolvimento (8100) e o arquivo de retransmissão ([proxyConfig]); no [tsconfig.json], as verificações estritas ([strict], [strictTemplates]).
11.5.1. package.json
| {
"name": "rdvmedecins-ionic",
"version": "0.0.0",
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build",
"watch": "ng build --watch --configuration development",
"android": "ng build && cap sync android && cap run android",
"captures": "node captures/captures.mjs"
},
"private": true,
"packageManager": "npm@10.9.4",
"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",
"@capacitor/android": "^8.5.2",
"@capacitor/app": "^8.1.2",
"@capacitor/core": "^8.5.2",
"@capacitor/preferences": "^8.0.1",
"@ionic/angular": "^9.0.6",
"ionicons": "^8.1.0",
"rxjs": "~7.8.0",
"tslib": "^2.3.0"
},
"devDependencies": {
"@angular/build": "^22.2.1",
"@angular/cli": "^22.2.1",
"@angular/compiler-cli": "^22.2.0",
"@capacitor/cli": "^8.5.2",
"playwright": "^1.56.1",
"prettier": "^3.8.1",
"typescript": "~6.0.2"
}
}
|
- Linhas 4–11: os scripts: [npm start] inicia o servidor de desenvolvimento, [npm run build] compila a aplicação, [npm run android] a compila, a copia para o projeto [Android] e a executa no celular; [npm run captures] gera as capturas de tela;
- linhas 14–29: os pacotes da aplicação: [Angular] (sem [@angular/animations] nem [zone.js]: a aplicação é “zoneless”, veja o exemplo 01), [Capacitor] (seu núcleo, a plataforma [Android], o plugin [App] que dá acesso ao botão Voltar e o plugin [Preferences] que armazena o idioma), [Ionic] e seus ícones; [rxjs] é a biblioteca dos [Observable] do cliente HTTP;
- linhas 30–38: ferramentas de desenvolvimento: o compilador do [Angular], o comando [ng], o comando [cap] do [Capacitor], o [Playwright] para as capturas de tela, o [Prettier] para a formatação do código, o [TypeScript].
NÃO há pacotes adicionais além dos dos exemplos: nenhuma biblioteca de tradução, de gerenciamento de estado ou de formulários. Tudo o que a aplicação precisa está no [Angular] e no [Ionic], e em alguns arquivos escritos aqui.
11.5.2. proxy.conf.json
| {
"/api": {
"target": "http://localhost:8080",
"secure": false,
"changeOrigin": false,
"logLevel": "warn"
}
}
|
O do exemplo 22: no desenvolvimento web, o [ng serve] encaminha as requisições /api para o servidor JSON. Para o navegador, a aplicação e a API têm a MESMA origem (http://localhost:8100): nenhuma autenticação CORS, e o cookie do token circula normalmente.
11.5.3. capacitor.config.ts
| // =========================================================================
// capacitor.config.ts - a configuração do Capacitor
// -------------------------------------------------------------------------
// O Capacitor transforma a aplicação web (a pasta produzida por ng build)
// em uma aplicação Android: ele a envolve em um projeto do Android Studio
// (pasta android/), onde ela é exibida por uma "WebView", o motor do
// navegador Chrome do celular. Comandos (veja o capítulo Implantação):
// npx cap add android (uma única vez: cria a pasta android/)
// ng build (compila a aplicação web)
// npx cap sync android (copia-a para o projeto Android)
// npx cap run android (executa-a em um emulador ou celular)
// =========================================================================
import type { CapacitorConfig } from '@capacitor/cli';
const config: CapacitorConfig = {
// o identificador único da aplicação no celular (e na Play Store)
appId: 'fr.stahe.rdvmedecins',
// o nome exibido sob o ícone
appName: 'RdvMedecins',
// a pasta da aplicação web compilada (ng build)
webDir: 'dist/rdvmedecins_ionic/browser',
server: {
// permite requisições HTTP não criptografadas (http://10.0.2.2:8080) ao
// servidor JSON de desenvolvimento (a ser removido em produção: HTTPS)
cleartext: true,
},
plugins: {
// CapacitorHttp: as requisições HTTP da aplicação deixam de ser feitas
// pela WebView e passam a ser feitas pelo código nativo do Android. Consequências (veja
// api/http-client.ts): nenhuma verificação de CORS (o servidor JSON não precisa
// permitir nada), e os cookies (o do token de autenticação) são
// armazenados pelo Android e reenviados automaticamente
CapacitorHttp: {
enabled: true,
},
},
};
export default config;
|
A configuração do [Capacitor] (veja o exemplo 01):
- linha 18: o ID da aplicação no celular (e na [Play Store]): o da aplicação [Flutter]. Portanto, as duas não podem ser instaladas ao mesmo tempo no mesmo celular; para compará-las, seria preciso alterar um dos IDs;
- linha 22: a pasta da aplicação web compilada, que o [npx cap sync] copia para o projeto [Android];
- linha 26: por padrão, o [Android] rejeita requisições HTTP não criptografadas; elas são permitidas para se conectar ao servidor de desenvolvimento ([http://10.0.2.2:8080]). Em produção, o servidor deve usar HTTPS;
- linhas 34–36: o plugin [CapacitorHttp] (exemplo 22): no celular, as requisições HTTP deixam de ser feitas pelo [WebView] e passam a ser feitas pelo código nativo do [Android]. O servidor, portanto, não precisa seguir nenhuma regra de CORS, e os cookies são armazenados e devolvidos pelo próprio [Android]. É isso que permite ao cliente [Ionic]dispensar o cliente HTTP “que gerencia cookies” do cliente [Flutter].
11.6. Inicialização da aplicação
11.6.1. src/app/config.ts
| // =========================================================================
// src/app/config.ts - ONDE está o servidor JSON?
// -------------------------------------------------------------------------
// A pergunta não se coloca para uma aplicação web servida pelo
// próprio servidor: as requisições vão para a MESMA origem da página
// (um endereço relativo, /api/...). Mas uma aplicação MOBILE não tem origem
// utilizável (no Android, a página é servida pelo Capacitor
// a partir de https://localhost): é preciso informar-lhe o endereço completo do servidor.
// - o emulador Android enxerga o computador que o executa
// no endereço 10.0.2.2 (localhost, para ele, é o próprio emulador);
// - um celular real, conectado à mesma rede Wi-Fi do computador, deve
// usar o endereço do computador nessa rede (192.168.1.20...):
// ele é informado ao compilar a aplicação:
// ng build --define "SERVER='http://192.168.1.20:8080'"
// - no desenvolvimento web (ng serve), o servidor de desenvolvimento
// do Angular encaminha as requisições /api ao servidor JSON (arquivo
// proxy.conf.json): um endereço relativo basta.
// =========================================================================
import { Capacitor } from '@capacitor/core';
// o valor dado por --define "SERVER='...'" na compilação
// (ng build, ng serve). A opção substitui, no código compilado, a palavra
// SERVER pelo valor informado. Sem ela, SERVER não existe: typeof
// nos permite verificá-lo sem causar um erro
declare const SERVER: string | undefined;
const forcedServer = typeof SERVER === 'string' ? SERVER : '';
export const config = {
// Capacitor.isNativePlatform(): true na aplicação Android (ou iOS),
// false em um navegador; Capacitor.getPlatform(): 'android', 'ios' ou 'web'
serverUrl:
forcedServer !== ''
? forcedServer
: !Capacitor.isNativePlatform()
? '' // a web: mesma origem, endereços relativos
: Capacitor.getPlatform() === 'android'
? 'http://10.0.2.2:8080'
: 'http://localhost:8080',
};
|
O endereço do servidor, de acordo com a plataforma (veja o exemplo 22):
- Linha 26: [declare const SERVER] declara ao compilador [TypeScript] uma constante que ele não vê em nenhum outro lugar; ela é fornecida pelo comando de compilação ([ng build --define "SERVER='...'"]). A opção [--define] SUBSTITUI, no código compilado, a palavra [SERVER] pelo valor informado: o endereço é gravado na aplicação compilada, como acontece com o [--dart-define] do [Flutter];
- linha 27: sem essa opção, [SERVER] não existe, e tentar lê-lo causaria um erro em tempo de execução; [typeof] é o único operador que aceita um nome desconhecido (nesse caso, ele devolve “undefined”);
- Linhas 32–39: caso contrário, um endereço web relativo (o servidor de desenvolvimento e, em produção, o próprio servidor JSON servem a página E a API), [10.0.2.2] no [Android] (o computador, visto do emulador), [localhost] nos demais casos. [Capacitor.isNativePlatform()] indica se a aplicação está sendo executada no ambiente nativo do [Capacitor] (e não em um navegador), e [Capacitor.getPlatform()] especifica em qual sistema.
11.6.2. src/main.ts
| // =========================================================================
// src/main.ts - o ponto de entrada da aplicação
// -------------------------------------------------------------------------
// Uma aplicação Angular começa com bootstrapApplication: o Angular cria
// o componente RAIZ (App) e o insere na tag <app-root> da página
// index.html. O segundo parâmetro fornece os "providers"
// de toda a aplicação: o Ionic, o roteador, o cliente HTTP e seu
// interceptor, o título das telas e o carregamento do idioma.
// Os serviços (sessão, mensagens, cache, traduções, API) não precisam
// ser declarados aqui: providedIn: 'root' os fornece a toda a aplicação.
// =========================================================================
import { provideHttpClient, withInterceptors } from '@angular/common/http';
import { inject, provideAppInitializer } from '@angular/core';
import { bootstrapApplication } from '@angular/platform-browser';
import { provideRouter, TitleStrategy, withComponentInputBinding } from '@angular/router';
import { provideIonicAngular } from '@ionic/angular';
import { apiInterceptor } from './app/api/http-client';
import { App } from './app/app';
import { routes } from './app/app.routes';
import { PageTitle } from './app/components/page-title';
import { Translations } from './app/i18n/translations';
bootstrapApplication(App, {
providers: [
// Ionic: modo 'md' (Material Design) = o visual do Android, mesmo no
// navegador de um computador
provideIonicAngular({ mode: 'md' }),
// o roteador: a lista de rotas (app.routes.ts);
// withComponentInputBinding: os parâmetros de uma rota (:id, ?day=...,
// data) são entregues aos inputs do componente da tela
provideRouter(routes, withComponentInputBinding()),
// o cliente HTTP do Angular, cada requisição do qual passa por nosso interceptor
provideHttpClient(withInterceptors([apiInterceptor])),
// os títulos de nossas telas são chaves de tradução (veja page-title.ts)
{ provide: TitleStrategy, useClass: PageTitle },
// antes da primeira tela: o idioma (lembrado, ou o do dispositivo)
// e seu dicionário. O Angular espera o fim da Promise retornada
provideAppInitializer(() => inject(Translations).start()),
],
}).catch((err) => console.error(err));
|
Inicialização. Aqui há apenas providers: os objetos compartilhados (a sessão, as mensagens, o cache, as traduções e a camada de acesso à API) são serviços [providedIn: 'root'], criados pelo [Angular] na primeira injeção (veja o exemplo 14).
- linha 28: o [Ionic], no modo [md] (a aparência do [Android]);
- linha 32: o roteador; [withComponentInputBinding()] fornece os parâmetros do endereço ([?day=...], [:id]) e os dados da rota ([data]) aos inputs dos componentes de tela (veja o exemplo 17). Assim, as telas nunca precisam ler o endereço por conta própria;
- linha 34: o cliente HTTP e seu interceptor (veja [api/http-client.ts]);
- linha 36: a “estratégia de títulos” do roteador é substituída pela nossa, que traduz os títulos (veja [components/page-title.ts]);
- linha 39: [provideAppInitializer]: uma função executada ANTES de a primeira tela ser exibida; se ela devolver uma [Promise], o [Angular] espera que ela termine. O dicionário do idioma de origem é carregado aqui: a primeira tela é exibida diretamente no idioma correto (é o [await translations.start()] colocado antes do [runApp] no cliente [Flutter]).
11.6.3. src/app/app.ts
| // =========================================================================
// src/app/app.ts - o componente RAIZ da aplicação
// -------------------------------------------------------------------------
// Ele exibe o layout (que contém o local das telas) e liga
// entre si os serviços da aplicação por dois mecanismos:
// 1. a sessão muda (login, logout, sessão expirada): os
// dados lidos para o usuário anterior não valem mais (o cache é
// limpo), e os guards do roteador são reavaliados para
// a tela atual: são eles que saem da tela de login
// após o login, ou que a ela devolvem após um logout;
// 2. as mensagens "flash": ao final de CADA navegação, as mensagens
// da tela anterior desaparecem, e as deixadas para a próxima
// tela aparecem (veja state/messages.ts).
// A sessão EXPIRADA (resposta 401) é tratada pelo interceptor
// (api/http-client.ts): ele limpa a sessão, e o mecanismo 1 faz o resto.
// Ele também conecta o botão Voltar do Android (veja back-button.ts).
// =========================================================================
import { Component, computed, effect, inject, untracked } from '@angular/core';
import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router } from '@angular/router';
import { IonApp, NavController } from '@ionic/angular';
import { filter } from 'rxjs';
import { handleBackButton } from './back-button';
import { Layout } from './components/layout';
import { Cache } from './state/cache';
import { Messages } from './state/messages';
import { Session } from './state/session';
@Component({
selector: 'app-root',
imports: [IonApp, Layout],
template: `
<ion-app>
<app-layout />
</ion-app>
`,
})
export class App {
private readonly session = inject(Session);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
private readonly navigation = inject(NavController);
// o papel do usuário logado (null: ninguém). Um novo nome
// (atualização da conta) não altera este signal: apenas o login
// e o logout o alteram
private readonly role = computed(() => this.session.user()?.role ?? null);
private url = '';
constructor() {
// o botão Voltar do Android
handleBackButton();
// 1a. a sessão muda: o cache é limpo
effect(() => {
this.session.user();
untracked(() => this.cache.clear());
});
// 1b. login, logout: os guards são reavaliados para o endereço
// atual. navigateRoot: a tela exibida substituirá toda a pilha de
// telas do Ionic (as do usuário anterior desaparecem);
// onSameUrlNavigation: 'reload': mesmo para o endereço atual, a
// navegação acontece (e os guards são executados)
effect(() => {
this.role();
untracked(() => {
// não antes da primeira navegação: ela cuida disso
if (!this.router.navigated) return;
void this.navigation.navigateRoot(this.router.url, { onSameUrlNavigation: 'reload', replaceUrl: true });
});
});
// 2. a cada navegação concluída (o endereço mudou): nova página
this.router.events
.pipe(
filter((e) => e instanceof NavigationEnd),
takeUntilDestroyed(),
)
.subscribe((e) => {
if (e.urlAfterRedirects !== this.url) {
this.url = e.urlAfterRedirects;
this.messages.newPage();
}
});
}
}
|
O componente raiz: ele exibe o layout e conecta os serviços da aplicação entre si, como fazia o [main.dart]:
- linhas 34–36: [ion-app], o contêiner de toda a aplicação [Ionic], e o layout (veja [components/layout.ts]), que contém os locais das telas;
- linha 48: o papel do usuário conectado, calculado a partir da sessão. Um signal calculado ([computed]) só notifica seus leitores se seu VALOR mudar: alterar o nome do usuário (“Gerenciar minha conta”) muda o usuário, mas não o seu papel;
- linha 53: o botão Voltar do [Android], ligado pela função de [back-button.ts] (abaixo);
- Linhas 55–58: 1a. Toda vez que o usuário muda, o cache é limpo: os dados lidos para o usuário anterior não têm relevância para o seguinte (um paciente não deve ver a agenda consultada pelo administrador). Um efeito ([effect]) é reexecutado quando um signal que ele leu muda: neste caso, [this.session.user()]. [untracked]: o que acontece em seguida não é uma dependência do efeito;
- linhas 64–71: 1b. A cada login ou logout, o sistema “navega de volta” para o endereço atual, o que reexecuta os guards do roteador (veja [app.routes.ts]): é o guard que sai da tela de login após um login bem-sucedido, ou volta a ela após um logout ou uma sessão expirada. É o [refreshListenable] do [go_router], criado manualmente. [navigateRoot] (do [NavController] do [Ionic]): a tela exibida substitui TODA a pilha de telas do [Ionic]; as telas do usuário anterior são destruídas. [onSameUrlNavigation: 'reload']: sem essa opção, o roteador ignora a navegação para o endereço atual;
- linha 68: na inicialização, o efeito é executado antes da primeira navegação, que de qualquer forma executará as verificações: nenhuma ação é realizada;
- Linhas 73–83: 2. Mensagens flash. O roteador publica seus eventos em um [Observable] ([router.events]); apenas os eventos de fim de navegação são mantidos ([filter]) e, se o endereço mudou, o sistema passa para uma “nova página”: as mensagens da tela anterior desaparecem, e as publicadas para esta aparecem (veja [messages.ts]). O botão Voltar, que fecha a janela de reserva, altera a URL: ele também apaga as mensagens. [takeUntilDestroyed()]: a assinatura termina junto com o componente (neste caso, com a aplicação).
| // =========================================================================
// src/app/back-button.ts - o botão Voltar do Android
// -------------------------------------------------------------------------
// No celular, o Capacitor recebe o toque no botão Voltar. Se ele não tiver
// nenhum listener para esse evento, apenas volta no histórico da
// WebView e depois fecha a aplicação: o Ionic não sabe de nada
// (um diálogo aberto não fecha, nem o menu lateral).
// O plugin @capacitor/app nos permite assinar esse evento: assim que há um
// listener, o Capacitor repassa o toque ao Ionic, que chama o handler
// de maior prioridade:
// - 100: um diálogo aberto (alert, ion-modal...) é fechado;
// - 99: o menu lateral aberto é fechado;
// - 1: (o nosso) voltamos à tela anterior; se não houver nenhuma,
// saímos da aplicação.
// No navegador, não há botão Voltar: não fazemos nada.
// =========================================================================
import { inject } from '@angular/core';
import { NavController, Platform } from '@ionic/angular';
import { App as CapacitorApp } from '@capacitor/app';
import { Capacitor } from '@capacitor/core';
// a ser chamado no construtor do componente raiz (contexto de injeção)
export function handleBackButton(): void {
if (!Capacitor.isNativePlatform()) return;
const navigation = inject(NavController);
// um listener (vazio): o Capacitor agora repassa o toque ao Ionic
void CapacitorApp.addListener('backButton', () => {});
inject(Platform).backButton.subscribeWithPriority(1, async () => {
// pop(): volta à tela anterior da pilha do Ionic; false: a
// pilha contém apenas a tela exibida, não há nada atrás
if (!(await navigation.pop())) {
await CapacitorApp.exitApp();
}
});
}
|
O mesmo arquivo dos exemplos (veja o exemplo 01, “O botão Voltar do Android”). Aqui, ele atribui as seguintes funções ao botão Voltar do celular, nesta ordem: fechar uma janela aberta (a janela de reserva, um pedido de confirmação, a lista de médicos, o calendário), fechar o menu lateral, voltar à tela anterior e, por fim, sair do aplicativo a partir da primeira tela.
11.6.5. src/styles.scss
| // =========================================================================
// src/styles.scss - os estilos de toda a aplicação
// -------------------------------------------------------------------------
// As folhas de estilo do Ionic: sem elas, seus componentes não têm
// seu visual. core.css é essencial; as outras são utilitários
// (margens, alinhamentos, classes ion-padding, ion-text-center...).
// =========================================================================
@use '@ionic/angular/css/core.css';
@use '@ionic/angular/css/normalize.css';
@use '@ionic/angular/css/structure.css';
@use '@ionic/angular/css/typography.css';
@use '@ionic/angular/css/padding.css';
@use '@ionic/angular/css/float-elements.css';
@use '@ionic/angular/css/text-alignment.css';
@use '@ionic/angular/css/text-transformation.css';
@use '@ionic/angular/css/flex-utils.css';
@use '@ionic/angular/css/display.css';
// a cor principal da aplicação (botões, barra superior): um índigo,
// como nos exemplos do curso. O Ionic deriva de --ion-color-primary as
// variantes mais clara (tint) e mais escura (shade)
:root {
--ion-color-primary: #3f51b5;
--ion-color-primary-rgb: 63, 81, 181;
--ion-color-primary-contrast: #ffffff;
--ion-color-primary-contrast-rgb: 255, 255, 255;
--ion-color-primary-shade: #37479f;
--ion-color-primary-tint: #5262bc;
}
// -------------------------------------------------------------------------
// os estilos comuns às telas do RdvMedecins
// -------------------------------------------------------------------------
// o título de uma tela
h1 {
font-size: 26px;
font-weight: 400;
margin: 8px 0 12px;
}
// o título de uma seção ("Conta do usuário")
h3 {
font-size: 15px;
font-weight: 500;
margin: 16px 0 12px;
}
// um texto de ajuda, em cinza
.help,
.intro {
font-size: 14px;
color: var(--ion-color-medium-shade);
}
// um pequeno espaço sob cada lista suspensa
ion-select {
margin-bottom: 12px;
}
// os botões de um formulário, lado a lado (um sob o outro se não
// couberem)
.buttons {
display: flex;
flex-wrap: wrap;
gap: 8px;
margin-top: 12px;
}
// as contas de demonstração da tela de login
.demo {
margin-top: 16px;
font-size: 13px;
color: var(--ion-color-medium-shade);
code {
font-family: 'Roboto Mono', monospace;
font-size: 12px;
}
}
// a caixa de confirmação (AlertController, veja confirmation.ts): um pouco
// mais larga, e seu botão "Sim" em vermelho
ion-alert.confirmation {
--min-width: 310px;
--max-width: 340px;
}
ion-alert.confirmation button.danger-button {
background: #d32f2f;
color: white;
border-radius: 20px;
padding: 0 16px;
}
// um diálogo (ion-modal) do tamanho de seu conteúdo, no centro da tela,
// em vez de ocupar a tela inteira (o padrão em um celular)
ion-modal.dialog {
--width: calc(100% - 48px);
--max-width: 420px;
--height: fit-content;
--border-radius: 16px;
}
|
Estilos comuns a todas as telas:
- linhas 9–18: as folhas de estilo do [Ionic] (veja o exemplo 01);
- linhas 23–30: a cor principal, o índigo, e suas variantes;
- linhas 37–60: títulos, textos de ajuda e o espaço abaixo das listas suspensas;
- linhas 64–69: botões de formulário, lado a lado ou um abaixo do outro se não couberem (o [Wrap] do [Flutter], em CSS: [flex-wrap: wrap]);
- linhas 72–81: as contas de demonstração na tela de login, em letras pequenas; os nomes de usuário em fonte monoespaçada;
- linhas 85–95: a caixa de confirmação, um pouco mais larga que a do [Ionic] (“Não, voltar” e “Sim, confirmar” cabem em uma linha), e seu botão vermelho. As caixas criadas pelo [AlertController] são adicionadas ao final da página, fora de qualquer componente: somente uma folha de estilo global pode afetá-las;
- Linhas 99–104: uma janela ([ion-modal]) da classe [dialog] assume o tamanho de seu conteúdo e é centralizada na tela. Em um celular, uma janela do [Ionic] ocupa a tela inteira por padrão; as janelas de reserva e de calendário se parecem, assim, com as caixas de diálogo do [Material]. [fit-content]: a altura do conteúdo.
11.7. A camada de acesso à API
11.7.1. src/app/api/api-client.ts
| // =========================================================================
// src/app/api/api-client.ts - TODAS as requisições à API passam por aqui
// -------------------------------------------------------------------------
// Extraído da camada de API dos exemplos (exemplo 24): um único método,
// request(), que constrói o endereço completo (config.serverUrl + /api +
// url), envia o corpo como JSON e retorna uma Promise da resposta.
//
// O cliente HTTP do Angular (HttpClient) passa cada requisição pelo
// INTERCEPTOR da aplicação (http-client.ts), que converte qualquer
// erro em um ApiError e trata, em UM único lugar, a resposta 401
// (sessão expirada).
// Algumas requisições tratam seu 401 por conta própria (o login, GET
// /api/auth/me...): elas são "públicas"; isso é sinalizado ao
// interceptor por meio do CONTEXTO da requisição (HttpContext).
// =========================================================================
import { HttpClient, HttpContext, HttpContextToken } from '@angular/common/http';
import { inject, Injectable } from '@angular/core';
import { firstValueFrom } from 'rxjs';
import { config } from '../config';
// uma informação anexada a uma requisição, lida pelo interceptor. Seu
// valor padrão (false): uma requisição protegida
export const PUBLIC = new HttpContextToken<boolean>(() => false);
export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE';
@Injectable({ providedIn: 'root' })
export class ApiClient {
private readonly http = inject(HttpClient);
// isPublic: true para as rotas que tratam o 401 por conta própria.
// Em caso de falha, a Promise é rejeitada com um ApiError
request<T>(method: Method, url: string, body?: unknown, isPublic = false): Promise<T> {
// http.request retorna um Observable; firstValueFrom o transforma em
// Promise (a requisição é enviada nesse momento). O objeto do corpo é enviado
// como JSON (cabeçalho content-type: application/json), a resposta JSON é
// decodificada (null se seu corpo estiver vazio)
return firstValueFrom(
this.http.request<T>(method, `${config.serverUrl}/api${url}`, {
body,
context: new HttpContext().set(PUBLIC, isPublic),
}),
);
}
}
|
Todas as requisições passam pelo método [request] (veja o exemplo 24):
- linha 24: um “token de contexto”—uma informação anexada a uma requisição que o interceptor pode ler. Seu valor padrão é fornecido pela função: [false], uma requisição protegida;
- linha 34: um método genérico: [request<Person[]>(...)] devolve uma [Promise<Person[]>]. [isPublic = false]: um parâmetro opcional, com seu valor padrão;
- linhas 39–44: [http.request] devolve um [Observable] (exemplo 22), que só envia a requisição quando é assinado; [firstValueFrom] o assina e devolve uma [Promise] com seu primeiro valor (a resposta). O corpo é um objeto [JavaScript]: o cliente HTTP o envia como JSON, com o cabeçalho [Content-Type] apropriado; o JSON da resposta é decodificado (em UTF-8: os acentos permanecem intactos). O contexto da requisição carrega a informação “pública”.
O cliente [Flutter] tratava aqui os erros e o código de status 401; o cliente [Ionic] os delega ao interceptor.
11.7.2. src/app/api/http-client.ts
| // =========================================================================
// src/app/api/http-client.ts - o INTERCEPTOR das requisições HTTP
// -------------------------------------------------------------------------
// Um interceptor é uma função pela qual passa TODA requisição do cliente
// HTTP do Angular (ele é declarado em main.ts:
// provideHttpClient(withInterceptors([apiInterceptor]))). Ele recebe a
// requisição e o handler "next" que a envia; pode modificar a primeira e
// transformar a resposta. O nosso trata os ERROS:
// - todo erro se torna um ApiError (veja api-error.ts);
// - a resposta 401 de uma requisição protegida (sessão expirada) é tratada
// AQUI, de uma vez por todas: o usuário é esquecido, o cache é
// limpo, a mensagem para a tela de login é preparada. Os guards
// do roteador, reavaliados quando a sessão muda (veja app.ts), então nos enviam
// de volta à tela de login.
//
// E o COOKIE do token JWT? O servidor o coloca em um cookie
// (httpOnly). O código da aplicação não tem NADA a fazer:
// - na web, é o navegador que armazena o cookie e o reenvia;
// - no Android, o plugin CapacitorHttp (habilitado em
// capacitor.config.ts) envia as requisições pelo código nativo
// do Android, que armazena os cookies e também os reenvia (e
// os mantém quando a aplicação é parada e reiniciada).
// =========================================================================
import { HttpErrorResponse, HttpInterceptorFn } from '@angular/common/http';
import { inject } from '@angular/core';
import { catchError, throwError } from 'rxjs';
import { Cache } from '../state/cache';
import { Messages } from '../state/messages';
import { Session } from '../state/session';
import { PUBLIC } from './api-client';
import { ApiError } from './api-error';
export const apiInterceptor: HttpInterceptorFn = (request, next) => {
// inject(): somente aqui, no início da função (depois, em
// catchError, não estamos mais em um "contexto de injeção")
const session = inject(Session);
const cache = inject(Cache);
const messages = inject(Messages);
const isPublic = request.context.get(PUBLIC);
// next(request): a requisição é enviada; pipe(catchError(...)): o que fazer
// se ela falhar (a resposta bem-sucedida passa sem alteração)
return next(request).pipe(
catchError((e: unknown) => {
// um erro que não vem do cliente HTTP: uma anomalia, deixe passar
if (!(e instanceof HttpErrorResponse)) return throwError(() => e);
const error = ApiError.fromResponse(e);
if (error.statusCode === 401 && !isPublic) {
session.forget();
cache.clear();
messages.flash({ success: false, key: 'ERRORS.SESSION_EXPIRED' });
// a tela que espera a resposta exibirá ESTA mensagem também
return throwError(() => new ApiError(401, 'ERRORS.SESSION_EXPIRED'));
}
return throwError(() => error);
}),
);
};
|
O interceptor de requisições: ele trata, em um ÚNICO lugar, todos os erros e, em particular, a resposta 401.
- Linha 34: um interceptor é uma função simples ([HttpInterceptorFn]), declarada no [main.ts]: ela recebe a requisição e a função [next], que a encaminha (ao servidor, ou ao próximo interceptor, se houver vários), e devolve o [Observable] da resposta;
- Linhas 37–39: os serviços exigidos pelo interceptor. [inject()] só é permitido no início da função, dentro do “contexto de injeção” em que o [Angular] a chama: mais adiante, no [catchError], esse contexto não existe mais;
- Linha 40: a requisição é pública? (veja [api-client.ts]);
- Linhas 44–58: [next(request)] envia a requisição; [pipe(catchError(...))] processa o [Observable] da resposta: uma resposta bem-sucedida passa sem alterações; um erro é processado pela função informada, que devolve um novo [Observable] (neste caso, ainda um erro: [throwError]);
- linha 47: um erro que não vem de uma resposta HTTP é uma anomalia do cliente: ele é repassado como está;
- linha 48: qualquer resposta de erro se torna um [ApiError] (veja [api-error.ts]);
- Linhas 49–55: um 401 em uma requisição protegida significa que a sessão expirou: o usuário é esquecido, o cache é limpo e a mensagem para a próxima tela é preparada. A transição de tela, porém, é tratada pelos guards do roteador, que são reavaliados quando a sessão muda (veja [app.ts]). Um erro ainda é devolvido (a tela que aguardava a resposta precisa saber que ela não chegou), com a chave [ERRORS.SESSION_EXPIRED]: se essa tela exibir o erro, será a mesma mensagem.
E o cookie do token? O cliente não precisa escrever NADA: na web, o navegador o armazena e o devolve; no [Android], o [CapacitorHttp] encaminha as requisições pelo código nativo, que também o armazena e o reenvia, e o mantém quando a aplicação é parada e reiniciada (veja o exemplo 23). Esta é a principal simplificação em relação ao cliente [Flutter], que tinha de ler ele mesmo o cabeçalho [Set-Cookie] e escrever o cabeçalho [Cookie].
11.7.3. src/app/api/api-error.ts
| // =========================================================================
// src/app/api/api-error.ts - UMA classe para todos os erros da API
// -------------------------------------------------------------------------
// Todas as respostas de erro do servidor RdvMedecins têm a mesma forma:
// { "statusCode": 409, "key": "ERRORS.LOGIN_TAKEN", "params": {...}, "fields": {...} }
// Mas uma requisição também pode falhar de OUTRA FORMA: nenhuma resposta
// (rede fora do ar, servidor parado, endereço errado), ou uma resposta que não
// vem do nosso servidor (uma página de erro de um proxy). Convertemos
// tudo isso em UMA classe, ApiError, que carrega a chave de tradução
// enviada pelo servidor (e, se houver, seus parâmetros e o erro de
// cada campo).
// =========================================================================
import { HttpErrorResponse } from '@angular/common/http';
// um objeto { name: texto }
export type Texts = Record<string, string>;
// "extends Error": um erro JavaScript completo (throw, catch, e
// a propriedade error() de um resource do Angular o mantém como está)
export class ApiError extends Error {
constructor(
readonly statusCode: number, // 0: o servidor não respondeu
readonly key: string, // p. ex. 'ERRORS.LOGIN_TAKEN'
readonly params: Texts = {},
readonly fields: Texts = {},
) {
super(`${statusCode} ${key}`);
this.name = 'ApiError';
}
// uma resposta de erro do cliente HTTP do Angular -> um ApiError
static fromResponse(response: HttpErrorResponse): ApiError {
// status 0: nenhuma resposta (rede fora do ar, servidor parado, endereço errado)
if (response.status === 0) {
return new ApiError(0, 'ERRORS.SERVER_UNREACHABLE');
}
// error: o corpo da resposta, já decodificado se for JSON
const body: unknown = response.error;
if (isObject(body) && typeof body['key'] === 'string') {
return new ApiError(response.status, body['key'], texts(body['params']), texts(body['fields']));
}
// sem key: o proxy ou a rede respondeu no lugar do servidor
return new ApiError(
response.status,
response.status >= 500 ? 'ERRORS.SERVER_UNREACHABLE' : 'ERRORS.SERVER_ERROR',
);
}
}
function isObject(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value);
}
// um objeto JSON { "name": "ERRORS..." } -> Texts (vazio caso contrário)
function texts(json: unknown): Texts {
if (!isObject(json)) return {};
return Object.fromEntries(Object.entries(json).map(([key, value]) => [key, String(value)]));
}
|
O do exemplo 24: qualquer requisição que falha termina com um [ApiError], que contém a chave de tradução da mensagem, seus parâmetros e o erro de cada campo.
- Linha 21: [extends Error]: um erro [JavaScript] de pleno direito. Isso é importante para os resources do [Angular] ([resource()], abordados mais adiante): seu signal [error()] preserva um [Error] como está, mas “envolve” qualquer outro valor rejeitado;
- linhas 22–27: os parâmetros do construtor precedidos por [readonly] se tornam propriedades do objeto: é uma notação abreviada do [TypeScript];
- linhas 35–37: [status] é 0 quando nenhuma resposta foi recebida (rede fora do ar, servidor fora do ar, endereço incorreto);
- linhas 39–42: [response.error]: o corpo da resposta de erro, já decodificado pelo cliente HTTP se for JSON. Seu tipo é [unknown]: seu formato é verificado ([isObject], uma chave do tipo texto [key]) antes de ser usado;
- linhas 44–47: nenhuma chave: o proxy ou a rede respondeu no lugar do servidor;
- linha 51: [value is Record<string, unknown>]: uma função “type guard”: quando ela devolve [true], o [TypeScript] sabe, mais adiante no código, que o valor é um objeto;
- linhas 56–59: um objeto JSON ([params], [fields]) como um objeto de texto.
11.7.4. src/app/api/types.ts
| // =========================================================================
// src/app/api/types.ts - os objetos JSON trocados com o servidor
// -------------------------------------------------------------------------
// A tradução, em tipos TypeScript, da API descrita no capítulo "O
// servidor, uma caixa-preta". São apenas DESCRIÇÕES:
// desaparecem na compilação e não verificam nada durante a
// execução. Elas permitem ao compilador verificar que o código
// só usa campos que existem, com o tipo correto.
// =========================================================================
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; // nome exibido: "Marie PELISSIER"
role: Role;
}
// GET /api/captcha
export interface Captcha {
id: string;
svg: string; // a imagem, em formato SVG (texto)
}
// um título, um primeiro nome, um sobrenome
export interface Identity {
title: string;
firstName: string;
lastName: string;
}
// "Mme Alice DURAND"
export function label(i: Identity): string {
return `${i.title} ${i.firstName} ${i.lastName}`;
}
// um médico ou um cliente: GET /api/doctors, GET /api/clients/:id...
export interface Person extends Identity {
id: number;
version: number; // bloqueio otimista: a ser reenviado com uma atualização
login?: string; // apenas para o ADMIN
}
// um horário
export interface Slot {
id: number;
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
// uma linha da agenda, com os DIREITOS do usuário logado
export interface ScheduleSlot extends Slot {
free: boolean;
patient: Identity | null; // null: livre, ou ocupado por outro paciente
mine: boolean; // a consulta do paciente logado
bookable: boolean;
appointmentId: number | null; // definido se o usuário pode cancelar
}
// GET /api/schedule?doctorId=...&day=...
export interface Schedule {
doctor: Person;
day: string; // "yyyy-MM-dd"
slots: ScheduleSlot[];
info: string | null; // chave de tradução (paciente que já tem uma consulta)
}
// uma consulta de GET /api/my-area
export interface Appointment {
id: number;
day: string;
slot: Slot;
doctor: Person;
}
// GET /api/my-area
export interface MyArea {
patient: Identity;
appointments: Appointment[];
}
// GET /api/my-account
export interface MyAccount extends Identity {
login: string;
version: number;
}
|
Os objetos JSON da API, de tipo [TypeScript] (veja o exemplo 24). São apenas DESCRIÇÕES: elas desaparecem durante a compilação e não realizam nenhuma verificação durante a execução (o cliente [Flutter], por sua vez, verificava o formato de cada resposta por meio da filtragem do [Dart] 3). Elas permitem que o compilador e o editor verifiquem se o código usa apenas campos que existem, com o tipo correto.
- Linha 11: um tipo “união de textos”: um papel só pode ser uma destas três strings, e o compilador verifica isso ([u.role === 'ADMNI'] seria um erro de compilação);
- Linhas 34–36: uma função, já que uma interface não pode conter código: “Mme Alice DURAND”;
- linhas 39–43: um médico ou um cliente: uma [Identity], mais um identificador, uma versão (o bloqueio otimista: ela será reenviada com uma modificação) e um login, que somente o ADMIN recebe (daí o ponto de interrogação: um campo opcional);
- Linhas 55–61: uma entrada da agenda, que mostra os DIREITOS do usuário conectado, calculados pelo servidor: [patient] só é exibido para quem está autorizado a vê-lo, [bookable] indica se o usuário pode fazer uma reserva; [appointmentId] só é fornecido a quem pode cancelar;
- Linhas 86–89: a conta do paciente conectado: sua identidade, login e versão.
11.7.5. src/app/api/rdvmedecins-api.ts
| // =========================================================================
// src/app/api/rdvmedecins-api.ts - um método por rota da API
// -------------------------------------------------------------------------
// A "camada de acesso a dados" do cliente: as telas chamam estes
// métodos tipados, sem saber nada sobre as URLs, o cliente HTTP ou o JSON.
// Se a API mudar, só este arquivo muda.
// Cada método retorna uma Promise; em caso de falha, ela é rejeitada
// com um ApiError (veja http-client.ts).
// Os dados enviados (formulários) são objetos Data simples:
// suas chaves são os nomes dos campos esperados pelo servidor - e os
// dos erros que ele devolve (ApiError.fields).
// =========================================================================
import { inject, Injectable } from '@angular/core';
import { ApiClient } from './api-client';
import { Schedule, Captcha, MyAccount, MyArea, Person, User } from './types';
// /api/doctors ou /api/clients: ambos são tratados da mesma forma
export type PersonType = 'doctors' | 'clients';
export type Data = Record<string, unknown>;
@Injectable({ providedIn: 'root' })
export class RdvMedecinsApi {
private readonly client = inject(ApiClient);
private get<T>(url: string, isPublic = false): Promise<T> {
return this.client.request<T>('GET', url, undefined, isPublic);
}
private post<T>(url: string, body: unknown, isPublic = false): Promise<T> {
return this.client.request<T>('POST', url, body, isPublic);
}
// ------------------------------------------------ login (rotas públicas)
captcha(): Promise<Captcha> {
return this.get('/captcha', true);
}
me(): Promise<User> {
return this.get('/auth/me', true);
}
logIn(login: string, password: string, captchaId: string, captcha: string): Promise<User> {
return this.post('/auth/login', { login, password, captchaId, captcha }, true);
}
async logOut(): Promise<void> {
await this.post('/auth/logout', {}, true);
}
// ------------------------------------------------ criação de conta (pública)
async registrationAccess(captchaId: string, captcha: string): Promise<void> {
await this.post('/register/access', { captchaId, captcha }, true);
}
async registrationAccessStatus(): Promise<boolean> {
const response = await this.get<{ valid?: boolean }>('/register/access', true);
return response?.valid === true;
}
async register(data: Data): Promise<string> {
const response = await this.post<{ login: string }>('/register', data, true);
return response.login;
}
// ------------------------------------------------ agenda e consultas
// doctorId undefined: para um médico logado, a SUA agenda
schedule(doctorId: number | undefined, day: string): Promise<Schedule> {
// URLSearchParams: "day=2026-10-05&doctorId=1", caracteres especiais codificados
const params = new URLSearchParams({ day });
if (doctorId !== undefined) params.set('doctorId', String(doctorId));
return this.get(`/schedule?${params}`);
}
async book(day: string, slotId: number, clientId: number | undefined): Promise<void> {
// clientId: undefined desaparece do JSON enviado
await this.post('/appointments', { day, slotId, clientId });
}
async cancelAppointment(appointmentId: number): Promise<void> {
await this.client.request('DELETE', `/appointments/${appointmentId}`);
}
// ------------------------------------------------ médicos e clientes
list(type: PersonType): Promise<Person[]> {
return this.get(`/${type}`);
}
read(type: PersonType, id: number): Promise<Person> {
return this.get(`/${type}/${id}`);
}
add(type: PersonType, data: Data): Promise<Person> {
return this.post(`/${type}`, data);
}
edit(type: PersonType, id: number, data: Data): Promise<Person> {
return this.client.request('PUT', `/${type}/${id}`, data);
}
async remove(type: PersonType, id: number): Promise<void> {
await this.client.request('DELETE', `/${type}/${id}`);
}
// ------------------------------------------------ a área do paciente
myArea(): Promise<MyArea> {
return this.get('/my-area');
}
myAccount(): Promise<MyAccount> {
return this.get('/my-account');
}
editMyAccount(data: Data): Promise<User> {
return this.client.request('PUT', '/my-account', data);
}
async deleteMyAccount(currentPassword: string): Promise<void> {
await this.client.request('DELETE', '/my-account', { currentPassword });
}
}
|
Um método por rota da API: esta é a classe do exemplo 24, ampliada.
- Linha 19: [/api/doctors] e [/api/clients] são tratadas da mesma forma: o tipo—uma união de duas strings—é também o nome da rota;
- linha 21: dados de formulário: um objeto cujas chaves são strings e cujos valores podem ser qualquer coisa;
- Linhas 23–25: um serviço fornecido para toda a aplicação, que recebe o [ApiClient] por injeção;
- linhas 35–50: as rotas públicas de login: um 401 tem aqui um significado específico (“ninguém está conectado”, “senha incorreta”) e não significa que a sessão expirou;
- linhas 48–50: um método [async] que não devolve nada ([Promise<void>]): não nos interessa a resposta do servidor; só importa o sucesso;
- linhas 57–60: o token de criação de conta é válido? [response?.valid]: o operador [?.] devolve [undefined] se a resposta estiver vazia, em vez de provocar um erro;
- linhas 69–74: os parâmetros do endereço, construídos pelo [URLSearchParams] (que os codifica). Um médico conectado solicita a agenda sem [doctorId]: o servidor devolve a agenda do próprio médico;
- linha 78: da mesma forma, [clientId] só é enviado se for conhecido (um paciente que reserva para si mesmo): [JSON.stringify] omite as propriedades iguais a [undefined];
- linhas 86–104: as cinco operações envolvendo médicos ou clientes: [/api/${type}];
- linhas 107–121: a área do paciente. A exclusão da conta envia um corpo em uma requisição [DELETE] (a senha atual): isso é permitido pelo HTTP e pelo [http.request].
11.8. Idiomas
11.8.1. src/app/i18n/translations.ts
| // =========================================================================
// src/app/i18n/translations.ts - os dicionários, o idioma atual
// -------------------------------------------------------------------------
// Extraído do exemplo 21. Os dicionários (public/i18n/fr.json, en.json)
// são os dos clientes Vue.js, Angular, React e Flutter: mesmas chaves,
// mesmas convenções ({{param}}, plurais _one / _other). O servidor só
// devolve CHAVES ("ERRORS.LOGIN_TAKEN"): é aqui que elas
// se tornam texto, no idioma escolhido pelo usuário.
// - t('KEY', { param: value }) : o texto do idioma atual;
// - changeLanguage('fr') : carrega o outro dicionário, e
// lembra a escolha no dispositivo.
// O idioma e o dicionário são SIGNALS: t() os lê, então qualquer
// template que exiba t('...') é atualizado quando o idioma muda.
// =========================================================================
import { Injectable, signal } from '@angular/core';
import { Preferences } from '@capacitor/preferences';
export const languages = ['fr', 'en'] as const;
export type Language = (typeof languages)[number]; // 'fr' | 'en'
// um dicionário: textos, armazenados em seções aninhadas
interface Dictionary {
[key: string]: string | Dictionary;
}
const LANGUAGE_KEY = 'rdvmedecins.language';
@Injectable({ providedIn: 'root' })
export class Translations {
private readonly _language = signal<Language>('en');
private readonly dictionary = signal<Dictionary>({});
readonly language = this._language.asReadonly();
// o idioma inicial: o lembrado no dispositivo, senão o do
// celular (se for conhecido), senão o inglês. Chamado uma vez,
// antes de a primeira tela ser exibida (provideAppInitializer, main.ts)
async start(): Promise<void> {
// Preferences: um armazenamento chave / valor no dispositivo (o
// localStorage do navegador na web)
const { value: stored } = await Preferences.get({ key: LANGUAGE_KEY });
const device = navigator.language.slice(0, 2); // "en-US" -> "en"
await this.changeLanguage(stored ?? device);
}
async changeLanguage(requested: string): Promise<void> {
const language: Language = languages.find((l) => l === requested) ?? 'en';
// fetch: os arquivos da pasta public/ são distribuídos com a aplicação
// (no Android também: um endereço RELATIVO não passa pelo CapacitorHttp)
const response = await fetch(`i18n/${language}.json`);
this.dictionary.set((await response.json()) as Dictionary);
this._language.set(language);
await Preferences.set({ key: LANGUAGE_KEY, value: language });
}
// "AREA.HELLO" -> dictionary['AREA']['HELLO']; undefined se ausente
private find(key: string): string | undefined {
let node: string | Dictionary | undefined = this.dictionary();
for (const part of key.split('.')) {
node = typeof node === 'object' ? node[part] : undefined;
}
return typeof node === 'string' ? node : undefined;
}
// uma arrow function: ela pode ser passada como está aos componentes
// (readonly t = inject(Translations).t), e mantém seu "this"
readonly t = (key: string, params: Record<string, unknown> = {}): string => {
let text: string | undefined;
const count = params['count'];
if (typeof count === 'number') {
// Intl.PluralRules: a forma do plural, conforme as regras do
// idioma ('zero', 'one', 'other'...); 0 é 'one' em francês
const form = new Intl.PluralRules(this._language()).select(count);
text = this.find(`${key}_${count === 0 ? 'zero' : form}`) ?? this.find(`${key}_${form}`);
}
text ??= this.find(key);
// uma chave desconhecida é exibida como está: o que falta é visto imediatamente
if (text === undefined) return key;
// {{name}} -> o valor do parâmetro name
return text.replace(/\{\{(\w+)\}\}/g, (whole, name: string) => (name in params ? String(params[name]) : whole));
};
}
|
A classe [Translations] do exemplo 21, agora um serviço fornecido para toda a aplicação e simplificado: os dicionários continuam com o mesmo nome ([public/i18n/fr.json]).
- Linha 19: [as const]: o array é fixo, e seu tipo é exatamente [readonly ['fr', 'en']]; a linha 20 infere o tipo [Language], ['fr' | 'en']: adicionar um idioma ao array o adiciona ao tipo;
- linhas 23–25: um dicionário: textos organizados em seções aninhadas (um tipo recursivo);
- linhas 31–33: o idioma e o dicionário são SIGNALS. Tudo o que lê [t(...)] (um template, um signal calculado, um efeito) também lê esses signals e, portanto, se atualiza quando o idioma muda: é o [notifyListeners()] do [ChangeNotifier] do [Flutter], sem escrever nada. [asReadonly()]: o restante da aplicação pode ler o idioma, mas somente este serviço pode alterá-lo;
- linhas 38–44: o idioma padrão: o selecionado em uma sessão anterior; caso contrário, o idioma do celular, se o aplicativo o conhecer; caso contrário, o inglês. [Preferences] (o plugin do [Capacitor], veja o exemplo 20) armazena pares chave-valor no dispositivo; em um navegador, ele usa o [localStorage]. [navigator.language]: o idioma do sistema (“en-US”);
- Linhas 46–54: trocar de idioma: o dicionário é lido pelo [fetch] a partir dos arquivos incluídos na aplicação (a pasta [public/], copiada sem modificações pelo [ng build]). No [Android], uma URL RELATIVA ([i18n/fr.json]) não é redirecionada pelo [CapacitorHttp]: ela é servida pela própria aplicação. O idioma desconhecido se torna o inglês;
- linhas 57–63: “AREA.HELLO” → [dictionary['AREA']['HELLO']], percorrendo seção por seção;
- linhas 67–81: a tradução de uma chave, incluindo plurais ([_zero], [_one], [_other]) e parâmetros ([{{name}}]), seguindo as convenções do [i18next], que são as mesmas usadas nos dicionários dos outros clientes. [Intl.PluralRules] conhece as regras de plural de cada idioma (em francês, 0 e 1 são singular). [t] é uma arrow function, não um método: ela mantém seu [this] quando copiada para um componente ([readonly t = inject(Translations).t]), o que todas as telas fazem.
11.8.2. Dicionários
Os dicionários são os do cliente [Flutter], sem alterações (eles próprios tirados do cliente [React], complementados com algumas chaves específicas do aplicativo mobile: o menu “Minha conta”, “Escolha o dia” etc.). O início do dicionário em francês, [public/i18n/fr.json]:
| {
"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",
"MENU_ACCOUNT": "Mon compte",
"CONNECTED_AS": "Connecté : {{name}}",
"RETRY": "Réessayer"
},
"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",
|
Um arquivo por idioma, com as mesmas chaves em cada um; um grupo de chaves por tela; as chaves [ERRORS.*] são as devolvidas pelo servidor.
11.9. O estado compartilhado
Três serviços com signals, fornecidos para toda a aplicação ([providedIn: 'root']), como o do exemplo 20.
11.9.1. src/app/state/session.ts
| // =========================================================================
// src/app/state/session.ts - QUEM está logado?
// -------------------------------------------------------------------------
// O usuário logado (ou null), em um SERVIÇO com signals fornecido a
// toda a aplicação (providedIn: 'root', veja o exemplo 20): legível pelas
// telas E pelos guards do roteador, reavaliados quando ele muda
// (veja app.ts).
//
// O próprio token JWT NÃO está aqui: ele está em um cookie (gerenciado pelo
// navegador na web, pelo código nativo do Android no celular). A
// sessão guarda apenas a DESCRIÇÃO do usuário ({ login, name, role }).
//
// Quando a aplicação inicia, a sessão está vazia: check() pergunta
// ao servidor, uma única vez, quem está logado (GET /api/auth/me).
// =========================================================================
import { inject, Injectable, signal } from '@angular/core';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { User } from '../api/types';
@Injectable({ providedIn: 'root' })
export class Session {
private readonly api = inject(RdvMedecinsApi);
private readonly _user = signal<User | null>(null);
// a versão "somente leitura" do signal, para o resto da aplicação
readonly user = this._user.asReadonly();
// true após um logout DESEJADO (botão, exclusão da conta); false
// após uma sessão expirada. Os guards a levam em conta (veja app.routes.ts)
private _voluntaryExit = false;
// a pergunta "quem está logado?" já foi feita ao servidor?
private checking?: Promise<void>;
get voluntaryExit(): boolean {
return this._voluntaryExit;
}
// só consulta o servidor na primeira vez (a Promise é mantida)
check(): Promise<void> {
this.checking ??= this.api.me().then(
(u) => this.change(u),
() => this.change(null), // 401: ninguém; ou servidor inacessível
);
return this.checking;
}
async logIn(login: string, password: string, captchaId: string, captcha: string): Promise<void> {
this.change(await this.api.logIn(login, password, captchaId, captcha));
}
// o usuário mudou de nome ou de login (PUT /api/my-account)
update(u: User): void {
this.change(u);
}
async logOut(): Promise<void> {
try {
await this.api.logOut();
} finally {
this.forget(true);
}
}
// sem perguntar nada ao servidor: sessão expirada, conta excluída
forget(voluntary = false): void {
this.change(null, voluntary);
}
// o signal muda: tudo o que o lê (layout, guards...) é notificado
private change(u: User | null, voluntary = false): void {
this._voluntaryExit = voluntary;
this._user.set(u);
}
}
// o que é deduzido do usuário (null: ninguém está logado)
export const isAdmin = (u: User | null): boolean => u?.role === 'ADMIN';
export const isPatient = (u: User | null): boolean => u?.role === 'USER';
// ADMIN e DOCTOR: agendam e cancelam as consultas de qualquer paciente
export const isManager = (u: User | null): boolean => u?.role === 'ADMIN' || u?.role === 'DOCTOR';
// a página inicial de cada papel, logo após o login
export const homePage = (u: User | null): string => (isPatient(u) ? '/my-area' : '/schedule');
|
Quem está conectado? A sessão armazena a DESCRIÇÃO do usuário (login, nome, papel), e não o token, que permanece no cookie do usuário.
- Linhas 24–26: o usuário, em um signal privado e modificável ([_user]), e sua versão somente leitura, para o restante da aplicação. O layout (que exibe o nome do usuário), o [app.ts] (que limpa o cache e reavalia os guards) e as telas leem essa informação;
- linhas 38–44: a pergunta “Quem está conectado?”, enviada ao servidor ([GET /api/auth/me]) é feita apenas UMA vez, na inicialização: [??=] atribui a [Promise] somente se [checking] for [undefined]. As chamadas seguintes devolvem a mesma [Promise], já resolvida: o guard do roteador pode chamar [check()] antes de cada navegação sem nenhum custo. Na inicialização, se o cookie contiver um token ainda válido, o usuário permanece conectado. [then(success, failure)]: um 401 (ninguém está conectado) ou um servidor inacessível resultam, ambos, em uma sessão vazia;
- linhas 46–48: o login: se o servidor recusar, [api.logIn] rejeita sua [Promise] com um [ApiError], [await] o relança, e [change] não é chamado;
- linhas 55–61: logout — o usuário é esquecido mesmo que o servidor não responda ([finally]);
- linhas 69–72: todas as alterações passam por aqui. [_voluntaryExit] distingue entre um logout intencional e uma sessão expirada (veja [app.routes.ts]); é definido ANTES de alterar o signal, que os guards leem;
- linhas 76–81: o que se deduz sobre o usuário, em termos de funções (o cliente [Flutter] usava uma extensão de [Dart]). [u?.role]: [undefined] se ninguém estiver conectado ([null]), sem teste prévio.
11.9.2. src/app/state/messages.ts
| // =========================================================================
// src/app/state/messages.ts - as mensagens exibidas ao usuário
// -------------------------------------------------------------------------
// Mesma apresentação dos outros clientes do RdvMedecins:
// - um SUCESSO é exibido no TOPO da tela (faixa verde);
// - um ERRO na PARTE INFERIOR (faixa rosa), sempre visível.
// Uma mensagem é uma CHAVE de tradução (+ seus parâmetros): ela é portanto
// traduzida novamente por conta própria se o usuário mudar de idioma.
//
// As mensagens "flash": uma ação que termina com uma mudança de
// tela (agendamento, adição de um médico...) deixa sua mensagem com
// flash(); ela será exibida na PRÓXIMA tela e depois desaparecerá na
// navegação seguinte. É app.ts que chama newPage() ao final de
// cada navegação.
// =========================================================================
import { effect, inject, Injectable, Resource, signal, untracked } from '@angular/core';
import { ApiError, Texts } from '../api/api-error';
export interface Message {
key: string;
params: Texts;
}
@Injectable({ providedIn: 'root' })
export class Messages {
readonly success = signal<Message | null>(null);
readonly error = signal<Message | null>(null);
// as mensagens a exibir na próxima tela
private pendingSuccess: Message | null = null;
private pendingError: Message | null = null;
showSuccess(key: string, params: Texts = {}): void {
this.success.set({ key, params });
this.error.set(null);
}
showError(key: string, params: Texts = {}): void {
this.error.set({ key, params });
this.success.set(null);
}
// um ApiError -> a mensagem da tela; qualquer outro erro é uma
// anomalia do cliente, que é deixada passar
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 a PRÓXIMA tela
flash({ success = true, key, params = {} }: { success?: boolean; key: string; params?: Texts }): void {
if (success) {
this.pendingSuccess = { key, params };
} else {
this.pendingError = { key, params };
}
}
// uma nova tela: as mensagens da anterior desaparecem, as mensagens
// flash aparecem
newPage(): void {
this.success.set(this.pendingSuccess);
this.error.set(this.pendingError);
this.pendingSuccess = null;
this.pendingError = null;
}
}
// a ser chamado no construtor de uma tela: a falha na leitura desses
// recursos (resource do Angular) exibe sua mensagem na parte inferior da tela
export function reportErrors(...resources: Resource<unknown>[]): void {
const messages = inject(Messages);
for (const resource of resources) {
// um effect: uma função executada novamente a cada vez que um signal que ela leu
// muda (aqui, o erro do resource)
effect(() => {
const error = resource.error();
// untracked: o que vem a seguir não deve se tornar uma dependência do effect
if (error) untracked(() => messages.showApiError(error));
});
}
}
|
Mensagens do aplicativo: uma mensagem de sucesso na parte superior da tela, uma mensagem de erro na parte inferior (veja [layout.html]).
- Linhas 20–23: uma mensagem consiste em um código de tradução (KEY) e seus parâmetros. Ela só é traduzida quando exibida; ao mudar o idioma, as mensagens exibidas são traduzidas novamente;
- Linhas 27–28: as mensagens de sucesso e de erro exibidas: dois signals lidos pelo layout;
- linhas 45–48: um [ApiError] torna-se a mensagem de erro da tela. Qualquer outra exceção é um problema do lado do cliente: ela é relançada para aparecer no console durante o desenvolvimento, em vez de ficar oculta;
- linhas 56–62: uma mensagem para a PRÓXIMA tela: uma ação que termina com uma mudança de tela (uma reserva, uma inclusão etc.) coloca sua mensagem aqui. O parâmetro é um objeto "desempacotado": [flash({ success: false, key: '...' })], com valores padrão; são os parâmetros nomeados de [Dart];
- linhas 66–71: chamada a cada mudança de endereço (veja [app.ts]): as mensagens da tela anterior desaparecem e as mensagens flash aparecem;
- linhas 76–87: uma função a ser chamada no construtor de uma tela: se a leitura de seus recursos falhar ([resource()], veja [schedule.ts]), sua mensagem é exibida na parte inferior da tela. Para cada recurso, um effect lê seu signal [error()]: ele é reexecutado a cada novo erro. Um effect só pode ser criado dentro de um contexto de injeção, como [inject()]: daí a exigência de chamar a função dentro de um construtor (ou na inicialização de um campo).
11.9.3. src/app/state/cache.ts
| // =========================================================================
// src/app/state/cache.ts - os dados já lidos do servidor
// -------------------------------------------------------------------------
// A lista de médicos quase nunca muda: não há necessidade de lê-la novamente a
// cada visita à agenda. O cache mantém a Promise de cada leitura,
// sob uma CHAVE ('doctors', 'schedule/1/2026-10-05'...):
//
// cache.read('doctors', () => api.list('doctors'))
//
// retorna a Promise já mantida, ou inicia a leitura e a mantém.
// Após uma mudança, as chaves envolvidas são INVALIDADAS (serão
// lidas novamente na próxima requisição): cache.invalidate('schedule').
// Uma leitura que falhou não é mantida: a próxima tentará novamente.
// Cada invalidação incrementa o signal de versão: uma tela ainda
// viva (mesmo oculta sob outra na pilha do Ionic) pode assim
// ler seus dados novamente (veja reloadAfterInvalidation, abaixo).
// É, em poucas linhas, o que faz a biblioteca TanStack Query do
// cliente React.
// =========================================================================
import { effect, inject, Injectable, signal, untracked, WritableResource } from '@angular/core';
@Injectable({ providedIn: 'root' })
export class Cache {
private readonly promises = new Map<string, Promise<unknown>>();
private readonly _version = signal(0);
readonly version = this._version.asReadonly();
read<T>(key: string, load: () => Promise<T>): Promise<T> {
let promise = this.promises.get(key) as Promise<T> | undefined;
if (promise === undefined) {
promise = load();
this.promises.set(key, promise);
// em caso de falha, esta Promise é esquecida (a próxima requisição tentará novamente)
promise.catch(() => this.promises.delete(key));
}
return promise;
}
// esquece todas as chaves que começam com prefix, e notifica as telas
invalidate(prefix: string): void {
for (const key of [...this.promises.keys()]) {
if (key.startsWith(prefix)) this.promises.delete(key);
}
this._version.update((v) => v + 1);
}
// mudança de usuário: tudo é esquecido, SEM notificar (as telas do
// usuário anterior estão prestes a desaparecer, não devem ler nada)
clear(): void {
this.promises.clear();
}
}
// a ser chamado no construtor de uma tela: seus resources são lidos novamente
// (reload) após cada invalidação do cache. reload() mantém o valor
// atual durante a nova leitura: a tela não "pisca"
export function reloadAfterInvalidation(...resources: WritableResource<unknown>[]): void {
const cache = inject(Cache);
const start = cache.version();
effect(() => {
// o effect é executado uma primeira vez quando é criado: esperamos uma
// invalidação REAL
if (cache.version() === start) return;
untracked(() => resources.forEach((r) => r.reload()));
});
}
|
Dados já lidos do servidor: o equivalente, em poucas linhas, de [TanStack Query] no cliente [React], e de [Cache] no cliente [Flutter].
- Linha 25: o cache armazena [Promise], não valores reais: duas telas que solicitam os mesmos dados enquanto eles estão em trânsito recebem a MESMA [Promise], e apenas uma requisição é enviada;
- Linhas 29–38: um método genérico: [read<Person[]>(...)] retorna uma [Promise<Person[]>] (o tipo [T] é inferido a partir da função [load]). Uma leitura que falha é ignorada ([catch]): a próxima requisição tentará novamente;
- linhas 41–46: após uma modificação, as chaves afetadas são descartadas e o signal [version] é incrementado: as telas que leem esse signal são notificadas;
- linhas 50–52: quando o usuário muda, tudo é limpo sem notificar ninguém: as telas do usuário anterior vão desaparecer; elas não têm nada para reler;
- linhas 58–67: uma função a ser chamada no construtor de uma tela: seus recursos são relidos após cada invalidação do cache. O effect lê [cache.version()]: ele é reexecutado a cada invalidação e relê os recursos ([reload()]). As telas do [Ionic] permanecem ativas, ocultas sob a tela exibida (a pilha do botão Voltar): após uma alteração, elas já estão atualizadas quando você retorna a elas. [reload()] mantém o valor atual durante a releitura: a tela não "pisca".
| // =========================================================================
// src/app/formatting.ts - a exibição de horários e dias
// -------------------------------------------------------------------------
// O servidor envia dados BRUTOS (startHour: 8, startMinute: 0; day:
// "2026-10-05"); a formatação, que depende do idioma, é responsabilidade
// do cliente (veja o exemplo 09). Usamos aqui a API Intl do JavaScript,
// que conhece as regras de todos os idiomas.
// =========================================================================
import { Slot } from './api/types';
const two = (n: number): string => n.toString().padStart(2, '0');
// "8:05" em vez de "8:5"
export const time = (h: number, m: number): string => `${h}:${two(m)}`;
// "8:00 - 8:20"
export const timeRange = (s: Slot): string => `${time(s.startHour, s.startMinute)} - ${time(s.endHour, s.endMinute)}`;
// uma data -> "yyyy-MM-dd" (o formato da API), no fuso horário do dispositivo
export const toDay = (d: Date): string => `${d.getFullYear()}-${two(d.getMonth() + 1)}-${two(d.getDate())}`;
export const today = (): string => toDay(new Date());
// "2026-10-05" -> 5 de outubro de 2026 às 0:00, horário local (new Date("2026-10-05")
// daria 0:00 em tempo universal: na noite anterior, em outro continente)
export function toDate(day: string): Date {
const [y, m, d] = day.split('-').map(Number);
return new Date(y, m - 1, d);
}
// true se day for uma data que existe, no formato yyyy-MM-dd
export function isValidDate(day: string): boolean {
if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return false;
return toDay(toDate(day)) === day; // 2026-02-30 -> 2026-03-02: rejeitada
}
// "lundi 5 octobre 2026" / "Monday, October 5, 2026"
export function longDay(day: string, language: string): string {
return new Intl.DateTimeFormat(language, { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric' }).format(
toDate(day),
);
}
|
Formatação dos dados brutos do servidor (veja o exemplo 09):
- linha 21: uma data no formato da API ("2026-10-05"), no fuso horário do dispositivo. [getMonth()] conta os meses a partir de 0;
- linhas 27–30: o inverso: "2026-10-05" → 5 de outubro às 0h, no horário local. [new Date('2026-10-05')] indicaria meia-noite no Tempo Universal Coordenado (UTC), ou seja, a oeste de Greenwich, na noite anterior;
- linhas 33–36: a data no endereço é válida? [new Date(2026, 1, 30)] resulta em 2 de março: verificamos se a mesma string é retornada;
- linhas 39–43: "segunda-feira, 5 de outubro de 2026", conforme o idioma: [Intl.DateTimeFormat]— a variante de formatação de [JavaScript]— suporta todos os idiomas. O cliente [Flutter] exigia o pacote [intl] para isso.
11.11. O roteador
11.11.1. src/app/app.routes.ts
| // =========================================================================
// src/app/app.routes.ts - as telas da aplicação e seus direitos de acesso
// -------------------------------------------------------------------------
// Os MESMOS endereços dos outros clientes (/login, /schedule, /doctors,
// /my-area...). Na web, eles são exibidos na barra de endereços;
// no celular, permanecem invisíveis, mas organizam a aplicação
// da mesma forma (e a pilha de telas do botão Voltar).
//
// Os GUARDS: a função guard (uma CanActivateFn) é chamada antes de
// CADA navegação para cada tela. Ela é assíncrona: na primeira
// vez (início da aplicação, F5 na web), espera a resposta do servidor
// à pergunta "quem está logado?" (session.check()). Depois
// verifica os direitos da tela solicitada (accessOf) e redireciona se
// necessário. runGuardsAndResolvers: 'always': os guards também são
// reavaliados quando "navegamos de novo" para o endereço atual, o que
// app.ts faz quando a sessão muda (login, logout, expiração).
// LEMBRETE: essas verificações são apenas uma CONVENIÊNCIA (não exibir uma tela
// inútil). A proteção dos dados é garantida pelo servidor, que
// verifica novamente o token e o papel a CADA requisição.
// =========================================================================
import { inject } from '@angular/core';
import { CanActivateFn, CanMatchFn, Router, Routes } from '@angular/router';
import { RdvMedecinsApi, PersonType } from './api/rdvmedecins-api';
import { Role } from './api/types';
import { Messages } from './state/messages';
import { homePage, Session } from './state/session';
import { keys } from './pages/persons-config';
// os direitos de acesso de uma tela: pública (sem login), ou reservada a
// certos papéis (roles ausente: todos os papéis logados)
interface Access {
public: boolean;
roles?: Role[];
}
export function accessOf(path: string): Access {
if (path === '/login' || path === '/register') return { public: true };
if (path.startsWith('/doctors') || path.startsWith('/clients')) return { public: false, roles: ['ADMIN'] };
if (path === '/my-area' || path === '/my-account') return { public: false, roles: ['USER'] };
if (path === '/schedule' || path === '/forbidden' || path === '/') return { public: false };
return { public: true }; // endereço desconhecido: a página 404, para todos
}
// somente um caminho INTERNO ("/doctors"): nunca "//other-site.com"
export function internalPath(r: string | undefined): string | undefined {
return r !== undefined && r.startsWith('/') && !r.startsWith('//') ? r : undefined;
}
// "3" -> 3; "", "abc", "-2", ausente (undefined) -> undefined
export function positiveInteger(value: string | undefined): number | undefined {
if (value === undefined || !/^\d+$/.test(value)) return undefined;
const n = Number(value);
return n > 0 ? n : undefined;
}
// o guard de TODAS as telas
export const guard: CanActivateFn = async (_route, state) => {
// inject() primeiro: depois de um await, não estamos mais em um contexto de injeção
const session = inject(Session);
const router = inject(Router);
await session.check();
const user = session.user();
// state.url: o endereço solicitado, parâmetros incluídos ("/schedule?doctorId=1...")
const url = router.parseUrl(state.url);
const path = state.url.split(/[?#]/)[0];
const access = accessOf(path);
if (access.public) {
// logado: a tela de login não faz mais sentido. É AQUI que se
// sai dela, logo após o login: a sessão mudou, os guards
// são reavaliados. Vamos para a tela solicitada antes do login
// (?redirect=...), senão para a página inicial do papel
if (path === '/login' && user !== null) {
return router.parseUrl(internalPath(url.queryParams['redirect']) ?? homePage(user));
}
return true;
}
if (user === null) {
// logout desejado: a tela de login, simplesmente
if (session.voluntaryExit) return router.parseUrl('/login');
// sessão expirada, endereço aberto sem estar logado: a tela
// solicitada é lembrada, para voltarmos a ela após o login
return router.createUrlTree(['/login'], { queryParams: { redirect: state.url } });
}
if (path === '/') return router.parseUrl(homePage(user));
if (access.roles !== undefined && !access.roles.includes(user.role)) return router.parseUrl('/forbidden');
// true: a navegação prossegue; uma UrlTree: ela é redirecionada
return true;
};
// um guard ESPECÍFICO de /register: sem um passe (captcha resolvido na
// tela de login), volta para a tela de login
const registrationGuard: CanActivateFn = async () => {
const api = inject(RdvMedecinsApi);
const messages = inject(Messages);
const router = inject(Router);
const valid = await api.registrationAccessStatus().catch(() => false);
if (valid) return true;
messages.flash({ success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT' });
return router.parseUrl('/login');
};
// /doctors/abc/edit: esta rota não "corresponde" (canMatch);
// o roteador tenta as seguintes, até a página 404 (**)
const validId: CanMatchFn = (_route, segments) => positiveInteger(segments[1]?.path) !== undefined;
// as três telas de gerenciamento dos médicos OU dos clientes (ADMIN);
// data: valores fixos, entregues aos inputs do componente (type)
function personRoutes(type: PersonType): Routes {
const c = keys(type);
const list = () => import('./pages/persons').then((m) => m.PersonsPage);
const form = () => import('./pages/person-form').then((m) => m.PersonFormPage);
return [
{ path: type, title: c.title, data: { type }, loadComponent: list },
{ path: `${type}/add`, title: c.add, data: { type }, loadComponent: form },
{
path: `${type}/:id/edit`,
title: c.edit,
data: { type },
canMatch: [validId],
loadComponent: form,
},
];
}
// as telas, sem seus guards; title: uma CHAVE de tradução (veja
// components/page-title.ts); loadComponent: o código da tela só é
// carregado na primeira visita (um arquivo JavaScript separado)
const screens: Routes = [
// "/": sempre redirecionado pelo guard (página inicial do papel, ou login)
{ path: '', pathMatch: 'full', children: [] },
{
path: 'login',
title: 'LOGIN.TITLE',
loadComponent: () => import('./pages/login').then((m) => m.LoginPage),
},
{
path: 'schedule',
title: 'SCHEDULE.PAGE_TITLE',
loadComponent: () => import('./pages/schedule').then((m) => m.SchedulePage),
},
...personRoutes('doctors'),
...personRoutes('clients'),
{
path: 'register',
title: 'REGISTRATION.TITLE',
canActivate: [registrationGuard],
loadComponent: () => import('./pages/register').then((m) => m.RegisterPage),
},
{
path: 'my-area',
title: 'AREA.TITLE',
loadComponent: () => import('./pages/patient-area').then((m) => m.PatientAreaPage),
},
{
path: 'my-account',
title: 'MY_ACCOUNT.TITLE',
loadComponent: () => import('./pages/my-account').then((m) => m.MyAccountPage),
},
{
path: 'forbidden',
title: 'ERROR_PAGE.TITLE',
data: { code: 403 },
loadComponent: () => import('./pages/error-page').then((m) => m.ErrorPage),
},
// um endereço que nenhuma rota descreve: a página 404
{
path: '**',
title: 'ERROR_PAGE.TITLE',
data: { code: 404 },
loadComponent: () => import('./pages/error-page').then((m) => m.ErrorPage),
},
];
// cada tela recebe o guard comum (antes de seus próprios guards)
export const routes: Routes = screens.map((r) => ({
...r,
canActivate: [guard, ...(r.canActivate ?? [])],
runGuardsAndResolvers: 'always',
}));
|
As telas do aplicativo, seus endereços e seus direitos de acesso (veja os exemplos 17 e 18).
- linhas 32–35: os direitos de acesso de uma tela: pública, ou restrita a certos papéis (se [roles] estiver ausente: todos os papéis);
- linhas 37–43: as permissões de cada endereço, em UM só lugar;
- linhas 46–48: o endereço [?redirect=] só é seguido se for um caminho INTERNO: na web, um endereço [/login?redirect=//pirate-site.com] enviado por e-mail não deve levar o usuário a outro lugar depois que ele fizer login;
- linhas 51–55: os parâmetros de uma URL são strings que qualquer pessoa pode digitar (na web): "abc" ou "-2" tornam-se [undefined];
- linhas 58–89: O guard, executado antes de navegar para qualquer tela (veja as linhas 176–180):
- linha 62: na primeira vez, o sistema aguarda a resposta do servidor à pergunta "quem está conectado?"; depois disso, essa chamada não tem custo. Um guard pode ser assíncrono ([async]): o roteador aguarda sua resposta;
- linhas 65–67: [state.url]: o endereço solicitado, incluindo os parâmetros; [router.parseUrl]: a decomposição (seu caminho, seus parâmetros [queryParams]);
- linhas 68–77: uma tela pública é acessível a todos; no entanto, um usuário conectado não tem o que fazer na tela de login: ele vai para a tela que solicitou antes de fazer login, ou para a tela inicial de seu papel. É assim que o aplicativo sai da tela de login após um login bem-sucedido: a própria tela de login não precisa navegar. Um guard que retorna uma [UrlTree] (um endereço analisado) REDIRECIONA a navegação;
- linhas 78–84: ninguém está conectado: segue-se para a tela de login. Depois que uma sessão expira, ou se um endereço protegido (na web) foi aberto diretamente, a tela solicitada ([?redirect=]) é guardada para voltar a ela após o login; depois de um logout intencional, não é. [createUrlTree] constrói o endereço codificando o parâmetro;
- linhas 85–88: [/] leva à página inicial do papel; se o papel for insuficiente, leva a uma página 403; caso contrário, [true]: a navegação continua;
- linhas 93–101: um guard ESPECÍFICO de um caminho: a criação de conta exige um passe, que o servidor emite quando o CAPTCHA é digitado ([POST /api/register/access], veja a tela de login). Sem ele, o usuário é devolvido à tela de login com uma mensagem;
- linha 105: um guard [CanMatchFn] não verifica se você tem o DIREITO de seguir para uma tela, mas sim se a rota CORRESPONDE ao endereço: [/doctors/abc/edit] não corresponde à rota [doctors/:id/edit]; o roteador tenta as rotas seguintes até chegar à página 404;
- linhas 109–124: uma função que gera as três rotas dos médicos OU dos clientes: [/doctors], [/doctors/add], [/doctors/:id/edit]. [:id]: um parâmetro de caminho, passado ao input [id] do componente; [data: { type }]: um valor fixo, passado ao seu input [type]. [title]: o título da tela (uma chave de tradução; veja [page-title.ts]);
- linhas 111–112: [loadComponent]: o código de uma tela só é carregado na primeira visita. [import()] carrega um módulo sob demanda; [ng build] armazena, portanto, cada tela em um arquivo [JavaScript] separado, e o aplicativo inicia mais rápido;
- linha 131: [/]: uma rota sem tela ([children: []]), sempre redirecionada pelo guard;
- linhas 132–136: [/login?login=jbernard] (após criar uma conta) preenche previamente o campo de login: o parâmetro [login] é atribuído ao campo de entrada de mesmo nome na tela de login;
- linhas 137–141: da mesma forma, os três parâmetros do calendário ([doctorId], [day], [book]) são atribuídos aos campos da tela: todo o layout da tela está contido no endereço (veja [schedule.ts]);
- linhas 160–172: página 403 e, para qualquer endereço não descrito por nenhuma rota (o caminho "curinga", dois asteriscos), página 404: a mesma tela, com um código diferente ([data]);
- linhas 176–180: cada rota recebe o guard comum antes de seus próprios guards. [runGuardsAndResolvers: 'always']: os guards são executados a cada navegação, mesmo para o endereço atual (por padrão, apenas quando o caminho ou seus parâmetros mudam). Isso é o que permite que [app.ts] os reavalie quando a sessão muda.
Essas verificações são apenas uma CONVENIÊNCIA: elas evitam que uma tela desnecessária seja exibida. A proteção dos dados é garantida pelo servidor, que reverifica o token e o papel a cada requisição.
11.12. Os componentes
11.12.1. src/app/components/layout.ts
| // =========================================================================
// src/app/components/layout.ts - o LAYOUT comum a todas as telas
// -------------------------------------------------------------------------
// O único componente do componente raiz (veja app.ts); ele envolve
// o local das telas (<ion-router-outlet>):
// - a barra superior: título, idioma (FR / EN), logout;
// - o menu lateral ("drawer", <ion-menu>), aberto pelo botão ☰: as
// telas permitidas ao papel do usuário. "Médicos" e "Pacientes"
// só aparecem para o ADMIN: uma mera conveniência de exibição, sendo a
// proteção real a do servidor;
// - uma mensagem de sucesso no TOPO;
// - a tela atual (<ion-router-outlet>);
// - a área de erro na PARTE INFERIOR.
// Em uma tela grande (web, tablet), o menu é exibido permanentemente
// à esquerda: esse é o trabalho de <ion-split-pane>.
// =========================================================================
import { Component, computed, inject, signal } from '@angular/core';
import { toSignal } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router, RouterLink } from '@angular/router';
import {
IonButton, IonButtons, IonChip, IonContent, IonFooter, IonHeader, IonIcon, IonItem, IonLabel, IonList,
IonMenu, IonMenuButton, IonMenuToggle, IonPopover, IonRouterLink, IonRouterOutlet, IonSplitPane, IonTitle,
IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import {
calendar, checkmarkCircle, close, alertCircle, home, logOutOutline, medkit, people, personCircle,
} from 'ionicons/icons';
import { filter, map } from 'rxjs';
import { User } from '../api/types';
import { Messages } from '../state/messages';
import { isAdmin, isPatient, Session } from '../state/session';
import { Language, languages, Translations } from '../i18n/translations';
// uma entrada de menu: caminho, chave do rótulo, ícone
interface MenuEntry {
path: string;
key: string;
icon: string;
}
export function menuEntries(u: User | null): MenuEntry[] {
if (u === null) return [];
return [
...(isPatient(u) ? [{ path: '/my-area', key: 'APP.MENU_MY_AREA', icon: 'home' }] : []),
{ path: '/schedule', key: 'APP.MENU_SCHEDULE', icon: 'calendar' },
...(isAdmin(u)
? [
{ path: '/doctors', key: 'APP.MENU_DOCTORS', icon: 'medkit' },
{ path: '/clients', key: 'APP.MENU_PATIENTS', icon: 'people' },
]
: []),
...(isPatient(u) ? [{ path: '/my-account', key: 'APP.MENU_ACCOUNT', icon: 'person-circle' }] : []),
];
}
@Component({
selector: 'app-layout',
imports: [
RouterLink, IonRouterLink, IonSplitPane, IonMenu, IonMenuToggle, IonMenuButton, IonHeader, IonToolbar, IonTitle,
IonButtons, IonButton, IonIcon, IonContent, IonList, IonItem, IonLabel, IonChip, IonPopover, IonRouterOutlet,
IonFooter,
],
templateUrl: './layout.html',
styleUrl: './layout.scss',
})
export class Layout {
private readonly session = inject(Session);
private readonly translations = inject(Translations);
readonly messages = inject(Messages);
readonly t = this.translations.t;
readonly language = this.translations.language;
readonly languages = languages;
readonly user = this.session.user;
readonly entries = computed(() => menuEntries(this.user()));
// o endereço atual, sem seus parâmetros: um signal construído a partir
// dos eventos do roteador (toSignal: Observable -> signal)
private readonly path = toSignal(
inject(Router).events.pipe(
filter((e) => e instanceof NavigationEnd),
map((e) => e.urlAfterRedirects.split('?')[0]),
),
{ initialValue: '' },
);
// o menu de idiomas: aberto ou não, e sob qual elemento
readonly languagesOpen = signal(false);
languagesEvent?: Event;
constructor() {
addIcons({ calendar, checkmarkCircle, close, alertCircle, home, logOutOutline, medkit, people, personCircle });
}
// a entrada de menu da tela atual
isActive(e: MenuEntry): boolean {
return this.path().startsWith(e.path);
}
// o botão de idioma: o menu de idiomas abre sob ele
openLanguages(event: Event): void {
this.languagesEvent = event;
this.languagesOpen.set(true);
}
// FR / EN: nenhuma requisição ao servidor, a tela é traduzida novamente na hora
changeLanguage(l: Language): void {
void this.translations.changeLanguage(l);
}
// a sessão é limpa; os guards do roteador, reavaliados, exibem
// a tela de login. catch: mesmo que o servidor não responda
logOut(): void {
this.session.logOut().catch(() => undefined);
}
}
|
O componente que envolve todas as telas: a barra superior, o menu e as mensagens. Ele é a contrapartida do widget [ShellRoute] no cliente [Flutter].
- Linhas 37–41: uma entrada de menu: uma interface;
- linhas 43–56: os itens de menu permitidos para o papel do usuário. [...(condition ? [entries] : [])]: o operador de espalhamento insere zero, um ou mais itens no array ([if] em uma lista de [Dart]);
- linhas 69–76: os serviços e o que o template exibe: o idioma, o usuário, as entradas de menu (um valor calculado: ele muda conforme o usuário);
- linhas 80–86: o endereço atual, para marcar a entrada de menu ativa. [toSignal] converte um [Observable] (eventos do roteador, filtrados para fins de navegação) em um signal legível pelo template; é preciso fornecer um valor inicial;
- linhas 88–89: o menu de idiomas: aberto ou fechado, e o evento (toque no botão) que o abre;
- linha 92: os ícones usados pelo template, registrados com [ionicons];
- linhas 107–109: mudar de idioma: nenhuma requisição é enviada ao servidor; o dicionário muda, e tudo o que exibe uma tradução é atualizado;
- linhas 113–115: logout: a sessão é limpa e os guards, reavaliados (veja [app.ts]), exibem a tela de login. [catch]: mesmo que o servidor não responda, o usuário é considerado desconectado.
11.12.2. src/app/components/layout.html
| <!-- ======================================================================
layout.html - o layout comum a todas as telas
====================================================================== -->
<!-- ion-split-pane: acima de 800 pixels de largura (when), o menu é
exibido permanentemente à esquerda do conteúdo; abaixo disso, é uma gaveta.
contentId: o identificador do conteúdo principal. disabled: sem menu
para um visitante que não está logado -->
<ion-split-pane contentId="main" when="(min-width: 800px)" [disabled]="!user()">
<ion-menu contentId="main" [disabled]="!user()">
<ion-content>
@if (user(); as u) {
<!-- o cabeçalho do menu: quem está logado -->
<div class="who">
<div class="name">{{ u.name }}</div>
<ion-chip [outline]="true">{{ u.role }}</ion-chip>
</div>
<ion-list lines="none">
@for (e of entries(); track e.path) {
<!-- ion-menu-toggle: tocar na entrada fecha a gaveta;
routerDirection="root": a tela escolhida substitui toda a
pilha de telas (sem voltar à tela anterior) -->
<ion-menu-toggle [autoHide]="false">
<ion-item
[button]="true"
[detail]="false"
[routerLink]="e.path"
routerDirection="root"
[class.active]="isActive(e)"
>
<ion-icon slot="start" [name]="e.icon" />
<ion-label>{{ t(e.key) }}</ion-label>
</ion-item>
</ion-menu-toggle>
}
</ion-list>
}
</ion-content>
</ion-menu>
<!-- o conteúdo principal: uma "página" do Ionic (classe ion-page: em coluna,
ocupando toda a altura) -->
<div class="ion-page" id="main">
<ion-header>
<ion-toolbar color="primary">
<!-- ion-menu-button: o botão ☰, que abre a gaveta. Ele se esconde
quando o menu está desativado ou exibido permanentemente -->
<ion-buttons slot="start">
<ion-menu-button />
</ion-buttons>
<ion-title>{{ t('APP.TITLE') }}</ion-title>
<ion-buttons slot="end">
<!-- o botão de idioma abre o popover declarado abaixo -->
<ion-button id="language-button" [title]="t('APP.LANGUAGE')" (click)="openLanguages($event)">
<strong>{{ language().toUpperCase() }}</strong>
</ion-button>
@if (user()) {
<ion-button [title]="t('APP.LOGOUT')" (click)="logOut()">
<ion-icon slot="icon-only" name="log-out-outline" />
</ion-button>
}
</ion-buttons>
</ion-toolbar>
</ion-header>
<!-- ion-popover: uma pequena janela, aberta (isOpen) sob o elemento
tocado (event); dismissOnSelect: fecha quando uma opção é escolhida;
didDismiss: foi fechada (por uma escolha ou por um toque fora dela) -->
<ion-popover
[isOpen]="languagesOpen()"
[event]="languagesEvent"
[dismissOnSelect]="true"
(didDismiss)="languagesOpen.set(false)"
>
<ng-template>
<ion-list lines="none">
@for (l of languages; track l) {
<ion-item [button]="true" [detail]="false" (click)="changeLanguage(l)">
<ion-label>{{ l.toUpperCase() }}</ion-label>
</ion-item>
}
</ion-list>
</ng-template>
</ion-popover>
<!-- a mensagem de sucesso, no topo -->
@if (messages.success(); as success) {
<ion-item class="message success" lines="none">
<ion-icon slot="start" name="checkmark-circle" />
<ion-label class="ion-text-wrap">{{ t(success.key, success.params) }}</ion-label>
<ion-button slot="end" fill="clear" color="dark" (click)="messages.clear()">
<ion-icon slot="icon-only" name="close" />
</ion-button>
</ion-item>
}
<!-- a tela atual -->
<div class="screen">
<ion-router-outlet />
</div>
<!-- a área de erro, na parte inferior: sempre visível, mesmo que a tela role.
ion-footer: acima da barra de navegação do celular -->
@if (messages.error(); as error) {
<ion-footer>
<ion-item class="message error" lines="none">
<ion-icon slot="start" name="alert-circle" />
<ion-label class="ion-text-wrap">{{ t(error.key, error.params) }}</ion-label>
<ion-button slot="end" fill="clear" color="dark" (click)="messages.clear()">
<ion-icon slot="icon-only" name="close" />
</ion-button>
</ion-item>
</ion-footer>
}
</div>
</ion-split-pane>
|
- linha 9: [ion-split-pane]: em uma tela grande (aqui, mais larga que 800 pixels: [when], uma "media query" CSS), o menu é exibido PERMANENTEMENTE à esquerda do conteúdo; em uma tela pequena, ele é uma gaveta, aberta pelo botão ☰. O layout do [Flutter]— criado aqui pelo próprio [Ionic] — fazia a escolha entre [NavigationDrawer] e [NavigationRail]. [contentId]: o identificador do conteúdo principal (linha 43). Nenhum menu para um visitante que não está conectado ([disabled]);
- linhas 10–39: [ion-menu]: o menu; no topo, para usuários conectados (o nome e o papel em um "marcador", [ion-chip]);
- linhas 23–34: um item de menu. [ion-menu-toggle] fecha a gaveta quando o item é tocado ([autoHide] como [false]: o item permanece visível quando o menu é exibido permanentemente). [routerLink]: o endereço da tela (veja o exemplo 17); [routerDirection="root"]: a tela selecionada SUBSTITUI toda a pilha de telas do [Ionic]: o botão Voltar não retorna à tela anterior (como em [context.go] e [go_router]). [class.active]: a classe CSS [active] é aplicada à entrada da tela atual;
- linha 43: o conteúdo principal: uma "página" do [Ionic] (classe [ion-page]: em coluna, ocupando toda a altura);
- linhas 44–64: a barra superior: o botão ☰ ([ion-menu-button], que se oculta automaticamente quando o menu está desativado ou exibido permanentemente), o título, o botão de idioma (seu texto, "FR" ou "EN") e o botão de logout (apenas para um usuário conectado);
- linhas 69–84: [ion-popover]: uma pequena janela, aberta ([isOpen]) abaixo do elemento tocado ([event]), que se fecha quando ([dismissOnSelect]); [didDismiss]: ela foi fechada, seja por uma seleção, seja por um toque ao lado. Seu conteúdo está em um [ng-template]: ele só é construído na abertura;
- linhas 87–95: a mensagem de sucesso, no topo, se houver uma. [@if (messages.success(); as success)]: a condição e seu valor armazenado em uma variável de template;
- Linhas 98–100: o local das telas, [ion-router-outlet] (veja o exemplo 17): o roteador exibe ali a tela do endereço atual. O [Ionic] gerencia a transição entre telas e mantém as telas anteriores na memória, ocultas: o botão Voltar retorna a elas sem recriá-las;
- linhas 104–114: a área de erro na parte inferior: [ion-footer], que permanece visível mesmo quando a tela rola e é posicionada acima da barra de navegação do telefone.
11.12.3. src/app/components/layout.scss
| // =========================================================================
// layout.scss - os estilos do layout
// =========================================================================
// o cabeçalho do menu. No celular, o drawer se estende sob a barra de
// status do Android (a hora, a bateria): sua altura é somada no topo
.who {
padding: calc(16px + var(--ion-safe-area-top, 0px)) 16px 8px 20px;
.name {
font-size: 18px;
font-weight: 500;
}
}
// a entrada de menu da tela atual: sobre um fundo colorido e arredondado
ion-item.active {
--background: rgba(var(--ion-color-primary-rgb), 0.14);
--border-radius: 28px;
margin: 0 8px;
font-weight: 500;
}
ion-menu-toggle ion-item {
margin: 0 8px;
}
// em uma tela grande: a largura do menu exibido permanentemente
ion-split-pane {
--side-width: 230px;
--side-min-width: 230px;
--side-max-width: 230px;
}
// o local das telas: toda a altura restante. <ion-router-outlet>
// é posicionado como "absolute": ele preenche este contêiner "relative"
.screen {
position: relative;
flex: 1;
}
// as faixas de mensagens
.message {
font-size: 17px;
}
.success {
--background: #e8f5e9;
--color: #1b5e20;
ion-icon[slot='start'] {
color: #388e3c;
}
}
.error {
--background: #f8d7da;
--color: #b71c1c;
ion-icon[slot='start'] {
color: #c62828;
}
}
|
Os estilos do layout. Eles se aplicam apenas aos elementos de [layout.html]: [Angular] "encapsula" os estilos de um componente.
- Linhas 7–8: o cabeçalho do menu (o nome e o papel do usuário). No telefone, o aplicativo ocupa a tela inteira, inclusive a barra superior em que o [Android] exibe a hora e o nível da bateria (a barra de status): a barra de ferramentas do [Ionic] ([ion-toolbar]) ajusta sua posição automaticamente, mas este simples [div] não. A variável CSS [--ion-safe-area-top], fornecida pelo [Ionic], especifica a altura dessa barra (0 em um navegador): ela é somada à margem superior. Sem ela, o nome se sobrepõe à hora;
- linhas 17–22: o item de menu ativo, sobre um fundo colorido e arredondado, como em um menu [Material] 3. [rgba(var(--ion-color-primary-rgb), 0.14)]: a cor principal, quase transparente;
- linhas 29–33: a largura do menu exibido permanentemente (caso contrário, 270 pixels);
- linhas 37–40: [ion-router-outlet] é definido como "absolute" (ele preenche seu elemento pai): é colocado em um contêiner que ocupa toda a altura restante ([flex: 1]), entre as mensagens;
- linhas 47–63: os banners de mensagem: verde para sucesso, rosa para erro, e as cores dos demais clientes.
11.12.4. src/app/components/page-title.ts
| // =========================================================================
// src/app/components/page-title.ts - o título da tela, traduzido
// -------------------------------------------------------------------------
// Na web: o título da aba; no Android: o nome da aplicação
// na lista de aplicações recentes. "Agenda - RdvMedecins"
//
// O roteador do Angular pode dar um título a cada tela: a
// propriedade title de uma rota (veja app.routes.ts). Após cada navegação, ele
// chama a "title strategy" (TitleStrategy). Substituímos a do Angular
// (veja main.ts) por esta: nossos títulos são
// CHAVES de tradução, e o título também deve mudar quando o idioma muda.
// =========================================================================
import { effect, inject, Injectable, signal } from '@angular/core';
import { Title } from '@angular/platform-browser';
import { RouterStateSnapshot, TitleStrategy } from '@angular/router';
import { Translations } from '../i18n/translations';
@Injectable()
export class PageTitle extends TitleStrategy {
private readonly title = inject(Title);
private readonly t = inject(Translations).t;
// a chave do título da tela atual
private readonly key = signal<string | undefined>(undefined);
constructor() {
super();
// executado novamente quando a chave muda (navegação) OU quando o idioma muda
// (t lê o dicionário, um signal)
effect(() => {
const key = this.key();
const application = this.t('APP.TITLE');
this.title.setTitle(key ? `${this.t(key)} - ${application}` : application);
});
}
// chamado pelo roteador após cada navegação; buildTitle: a
// propriedade title da rota exibida
override updateTitle(state: RouterStateSnapshot): void {
this.key.set(this.buildTitle(state));
}
}
|
O título da tela, traduzido: o título do documento, o título da aba na web. O roteador do [Angular] sabe atribuir um título a cada tela: a propriedade [title] de sua rota (veja [app.routes.ts]); após cada navegação, ele chama a "estratégia de título" ([TitleStrategy]), que [main.ts] substitui por esta.
- linha 19: [@Injectable()] sem [providedIn]: o serviço é fornecido por [main.ts], em vez de pelo do [Angular];
- Linhas 30–34: um effect, reexecutado quando a chave do título muda (um evento de navegação) OU quando o idioma muda ([t] lê o dicionário, um signal). [Title]: o serviço do [Angular] que grava o título da página;
- linhas 39–41: chamado pelo roteador após cada navegação; [buildTitle] define a propriedade [title] da rota exibida.
O cliente [Flutter] envolve cada tela em um widget [PageTitle]; aqui, os títulos são declarados junto com as rotas.
| // =========================================================================
// src/app/components/form-submission.ts - envio de um formulário ao servidor
// -------------------------------------------------------------------------
// Todos os formulários da aplicação seguem o mesmo padrão do
// exemplo 25: nenhuma regra é verificada no celular (elas vivem
// em UM único lugar, o servidor), e em caso de rejeição:
// - o erro de cada campo (ApiError.fields) é exibido sob o campo;
// - a mensagem geral (ApiError.key) é exibida na parte inferior da tela.
// Esta classe agrupa essas etapas. Não é um serviço: uma tela
// cria uma por formulário (new), com seus próprios signals:
//
// readonly submission = new FormSubmission(inject(Messages));
// if (await this.submission.submit(() => api.register(form))) { ... }
// <app-input-field ... [error]="submission.errors()['lastName']" />
// =========================================================================
import { signal } from '@angular/core';
import { ApiError, Texts } from '../api/api-error';
import { Messages } from '../state/messages';
export class FormSubmission {
// o erro de cada campo: uma CHAVE de tradução
readonly errors = signal<Texts>({});
// os parâmetros das mensagens de erro ({{min}}...), devolvidos pelo servidor
readonly params = signal<Texts>({});
readonly inProgress = signal(false);
constructor(private readonly messages: Messages) {}
// executa o envio; retorna true se teve sucesso. Em caso de ApiError, os
// erros são exibidos e false é retornado
async submit(action: () => Promise<unknown>): Promise<boolean> {
if (this.inProgress()) return false; // sem envio duplo
this.errors.set({});
this.params.set({});
this.inProgress.set(true);
try {
await action();
return true;
} catch (e) {
// qualquer outro erro é uma anomalia: showApiError o lança novamente
this.messages.showApiError(e);
const error = e as ApiError;
this.errors.set(error.fields);
this.params.set(error.params);
return false;
} finally {
this.inProgress.set(false);
}
}
// o usuário altera um campo: seu erro desaparece
clearError(field: string): void {
if (field in this.errors()) {
// um NOVO objeto, sem este campo: o signal muda de valor
const { [field]: _removed, ...others } = this.errors();
this.errors.set(others);
}
}
}
|
O envio de um formulário ao servidor: o [Command] do exemplo 23, complementado com erros de campo (exemplo 25). Isto não é um serviço: cada formulário cria o seu próprio ([new]), com seus próprios signals.
- Linhas 23–26: o erro de cada campo (uma chave de tradução), os parâmetros da mensagem e o envio em andamento (os botões ficam desativados). Três signals, que os templates leem;
- linha 28: [private readonly messages]: um parâmetro de construtor que se torna uma propriedade (veja [api-error.ts]);
- Linhas 32–50: o envio: sem envios duplicados; se ocorrer um [ApiError], a mensagem geral na parte inferior da tela e o erro de cada campo. [finally] é executado em todos os casos, mesmo após um [return];
- Linhas 53–59: o usuário corrige um campo; o erro desaparece. Um NOVO objeto é criado, sem esse campo ([const { [field]: _removed, ...others } = ...]: uma atribuição por desestruturação, cujo restante, [others], contém todos os campos, exceto esse): um signal só notifica seus ouvintes se seu valor mudar, e modificar o próprio objeto não o alteraria.
| // =========================================================================
// src/app/components/input-field.ts - um campo de formulário completo
// -------------------------------------------------------------------------
// Rótulo + campo + mensagem de ajuda OU mensagem de erro. Todos os
// formulários da aplicação o utilizam:
//
// <app-input-field label="PERSONS.LASTNAME_LABEL" [maxLength]="20"
// [value]="form().lastName" (valueChange)="update('lastName', $event)"
// [error]="submission.errors()['lastName']" />
//
// É um componente CONTROLADO (veja o exemplo 11): o valor pertence ao
// formulário pai, que o fornece (input value) e o recebe a
// cada tecla digitada (output valueChange). label, help e error são
// CHAVES de tradução; params, os parâmetros de suas mensagens ({{min}}...).
// =========================================================================
import { Component, inject, input, output } from '@angular/core';
import { InputCustomEvent, IonInput } from '@ionic/angular';
import type { AutocompleteTypes } from '@ionic/core';
import { Texts } from '../api/api-error';
import { Translations } from '../i18n/translations';
@Component({
selector: 'app-input-field',
imports: [IonInput],
templateUrl: './input-field.html',
styles: `
:host {
display: block;
margin-bottom: 8px;
}
`,
})
export class InputField {
readonly t = inject(Translations).t;
// input.required: um input obrigatório (erro de compilação se o pai esquecer)
readonly label = input.required<string>();
readonly value = input.required<string>();
readonly error = input<string>();
readonly help = input<string>();
readonly params = input<Texts>({});
readonly secret = input(false); // uma senha: caracteres ocultos
readonly maxLength = input<number>();
// para o gerenciador de senhas do celular ('username', 'current-password'...)
readonly autocomplete = input<AutocompleteTypes>('off');
readonly valueChange = output<string>();
// ionInput: a cada tecla digitada (ionChange: somente quando o campo perde o foco)
change(event: InputCustomEvent): void {
this.valueChange.emit(event.detail.value ?? '');
}
}
|
Um campo de formulário completo: rótulo, campo, texto de ajuda ou mensagem de erro. Todos os formulários o usam.
- linhas 38–46: os inputs (veja o exemplo 10). O rótulo, o texto de ajuda e a mensagem de erro são CHAVES de tradução. [input.required]: um input obrigatório; se omitido pelo pai, causa um erro de compilação. [AutocompleteTypes]: o tipo, fornecido pelo [Ionic], dos valores permitidos para o atributo HTML [autocomplete];
- linha 48: o output (veja o exemplo 11): o novo valor, a cada tecla digitada. Um componente CONTROLADO: o valor pertence ao pai, que o fornece ([value]) e o recebe ([valueChange]). Quando o próprio pai o altera (o CAPTCHA é limpo após uma falha), o campo acompanha: não há nada a escrever, ao contrário do [didUpdateWidget] do cliente [Flutter];
- linhas 51–53: [ionInput]: o evento do [ion-input] a cada tecla digitada ([ionChange] ocorre apenas quando o campo perde o foco); [detail.value] pode ser [null] ou [undefined]: nesse caso, uma string vazia é enviada.
| <!-- ======================================================================
input-field.html - o template de um campo de formulário
====================================================================== -->
<!-- fill="outline": um campo com moldura; labelPlacement="floating": o
rótulo fica no campo vazio e "floats" sobre a moldura assim que o campo recebe
o foco ou um valor;
helperText / errorText: as mensagens sob o campo. errorText só é
exibido (em vermelho, no lugar da ajuda) se o campo tiver as
classes ion-invalid E ion-touched -->
<ion-input
[label]="t(label())"
fill="outline"
labelPlacement="floating"
[type]="secret() ? 'password' : 'text'"
[value]="value()"
[maxlength]="maxLength()"
[autocomplete]="autocomplete()"
[autocorrect]="secret() ? 'off' : 'on'"
[helperText]="help() ? t(help()!, params()) : undefined"
[errorText]="error() ? t(error()!, params()) : undefined"
[class.ion-invalid]="!!error()"
[class.ion-touched]="!!error()"
(ionInput)="change($event)"
/>
|
- linhas 13–14: um campo com moldura ([fill="outline"]), cujo rótulo fica no campo vazio e "flutua" sobre a moldura assim que ele recebe o foco ou um valor;
- linha 15: uma senha é ocultada;
- linhas 17–19: [maxlength] restringe a entrada; [autocomplete] informa ao gerenciador de senhas do telefone o que o campo contém (um nome de usuário, uma senha ou uma nova senha); o corretor ortográfico não verifica senhas;
- linhas 20–23: as mensagens de ajuda e de erro aparecem abaixo do campo. [ion-input] exibe o erro (em vermelho, no lugar do texto de ajuda) somente se o campo tiver as classes CSS [ion-invalid], e [ion-touched]: elas são definidas quando há um erro. Essas classes geralmente são definidas pelos formulários do [Angular] (exemplo 08); aqui, é o SERVIDOR que determina a validade. O que os exemplos 07 e 11 desaconselhavam (definir essas classes manualmente) funciona aqui: [Ionic] de fato as remove na tecla seguinte, mas essa tecla também apaga o erro ([clearError]), que não deve mais ser exibido;
- Linha 24: cada tecla digitada chama [change].
11.12.8. src/app/components/person-fields.ts
| // =========================================================================
// src/app/components/person-fields.ts - título, primeiro nome, sobrenome
// -------------------------------------------------------------------------
// Os campos de identidade, comuns a três formulários: médico / cliente do
// ADMIN, "Criar uma conta de paciente" e "Gerenciar minha conta". O pai
// lhe passa os valores, os erros, e recebe cada mudança:
// <app-person-fields [values]="form()" [errors]="submission.errors()"
// (fieldChange)="update($event.field, $event.value)" />
// =========================================================================
import { Component, inject, input, output } from '@angular/core';
import { IonSelect, IonSelectOption, SelectCustomEvent } from '@ionic/angular';
import { Texts } from '../api/api-error';
import { Data } from '../api/rdvmedecins-api';
import { Translations } from '../i18n/translations';
import { InputField } from './input-field';
export const titles = ['Mr', 'Mme', 'Melle'];
export interface FieldChange {
field: string;
value: string;
}
@Component({
selector: 'app-person-fields',
imports: [IonSelect, IonSelectOption, InputField],
templateUrl: './person-fields.html',
})
export class PersonFields {
readonly t = inject(Translations).t;
readonly titles = titles;
readonly values = input.required<Data>();
readonly errors = input.required<Texts>();
readonly fieldChange = output<FieldChange>();
// o valor de um campo, como texto
value(field: string): string {
return String(this.values()[field] ?? '');
}
update(field: string, value: string): void {
this.fieldChange.emit({ field, value });
}
chooseTitle(event: SelectCustomEvent<string>): void {
this.update('title', event.detail.value);
}
}
|
Os campos de identidade (título, nome, sobrenome), comuns aos formulários de ADMIN, ao formulário de criação de conta e ao formulário "Gerenciar minha conta".
- linhas 34–36: o pai passa os valores e os erros, e recebe UM output para qualquer campo: seu nome e seu novo valor;
- linhas 39–41: o valor de um campo, como texto (os valores de formulário são do tipo [unknown]);
- linhas 47–49: o título selecionado na lista; [SelectCustomEvent<string>]: o evento do [ion-select], cujo valor é um texto.
11.12.9. src/app/components/person-fields.html
| <!-- ======================================================================
person-fields.html - título, nome, sobrenome
====================================================================== -->
<!-- ion-select: uma lista suspensa, com rótulo e mensagem de erro;
interface="popover": a lista abre sob o campo -->
<ion-select
[label]="t('PERSONS.TITLE_LABEL')"
fill="outline"
labelPlacement="floating"
interface="popover"
[value]="value('title')"
[errorText]="errors()['title'] ? t(errors()['title']) : undefined"
[class.ion-invalid]="!!errors()['title']"
[class.ion-touched]="!!errors()['title']"
(ionChange)="chooseTitle($event)"
>
@for (title of titles; track title) {
<ion-select-option [value]="title">{{ title }}</ion-select-option>
}
</ion-select>
<app-input-field
label="PERSONS.FIRSTNAME_LABEL"
[maxLength]="20"
[value]="value('firstName')"
(valueChange)="update('firstName', $event)"
[error]="errors()['firstName']"
/>
<app-input-field
label="PERSONS.LASTNAME_LABEL"
[maxLength]="20"
[value]="value('lastName')"
(valueChange)="update('lastName', $event)"
[error]="errors()['lastName']"
/>
|
- linhas 7–21: o título, em uma lista suspensa ([ion-select], veja o exemplo 05), com rótulo e mensagem de erro, como um campo de entrada; [interface="popover"]: a lista abre abaixo do campo (por padrão, em uma caixa de diálogo);
- linhas 23–36: nome e sobrenome: dois campos de entrada. As mensagens de erro aparecem sob o nome de campo esperado pelo servidor ([errors()['firstName']]).
11.12.10. src/app/components/captcha-field.ts
| // =========================================================================
// src/app/components/captcha-field.ts - a imagem do captcha e o campo de entrada
// -------------------------------------------------------------------------
// Um componente de exibição: a imagem (svg), o botão "Outra imagem"
// (output reload), e o campo, CONTROLADO pelo formulário pai
// (value, valueChange). A imagem e seu identificador são solicitados ao
// servidor pela página de login, que precisa deles para enviar a resposta.
// =========================================================================
import { Component, computed, inject, input, output } from '@angular/core';
import { IonButton, IonIcon } from '@ionic/angular';
import { addIcons } from 'ionicons';
import { refresh } from 'ionicons/icons';
import { Translations } from '../i18n/translations';
import { InputField } from './input-field';
@Component({
selector: 'app-captcha-field',
imports: [IonButton, IonIcon, InputField],
templateUrl: './captcha-field.html',
styles: `
.label {
font-size: 13px;
color: var(--ion-color-step-700, #444);
}
.row {
display: flex;
align-items: center;
gap: 8px;
}
.image {
width: 160px;
height: 54px;
background: #f5f7fa;
border: 1px solid #d0d0d0;
border-radius: 6px;
object-fit: contain;
}
`,
})
export class CaptchaField {
readonly t = inject(Translations).t;
readonly svg = input<string>();
readonly value = input.required<string>();
readonly error = input<string>();
readonly valueChange = output<string>();
readonly reload = output<void>();
// a imagem SVG (texto) -> um endereço "data:" que uma tag <img> pode
// exibir. Uma imagem não pode executar nenhum script: é segura
readonly source = computed(() => {
const svg = this.svg();
return svg ? `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}` : undefined;
});
constructor() {
addIcons({ refresh });
}
}
|
A imagem do CAPTCHA, o botão "Outra imagem" e o campo de entrada. O componente não chama o servidor: a tela de login solicita a imagem porque precisa do identificador dela para enviar a resposta.
- Linhas 21–39: os estilos do componente, escritos no próprio componente ([styles]): eles são curtos;
- linha 48: um output vazio ([output<void>()]): "o usuário quer outra imagem";
- Linhas 52–55: a imagem SVG é recebida como texto (exemplo 22). Ela é convertida em uma URL "data:" (o conteúdo do arquivo codificado na própria URL), que uma tag [img] pode exibir. Isso é seguro: uma imagem não pode executar scripts, ao passo que um SVG inserido na página por [innerHTML] poderia ([Angular] o rejeitaria, a menos que fosse explicitamente autorizado).
11.12.11. src/app/components/captcha-field.html
| <!-- ======================================================================
captcha-field.html - a imagem do captcha e o campo de entrada
====================================================================== -->
<div class="label">{{ t('CAPTCHA.LABEL') }}</div>
<div class="row">
@if (source(); as source) {
<!-- alt: o que um leitor de tela lê no lugar da imagem -->
<img class="image" [src]="source" [alt]="t('CAPTCHA.IMAGE_ALT')" />
} @else {
<div class="image"></div>
}
<ion-button fill="clear" (click)="reload.emit()">
<ion-icon slot="start" name="refresh" />
{{ t('CAPTCHA.NEW_IMAGE') }}
</ion-button>
</div>
<app-input-field
label="CAPTCHA.LABEL"
help="CAPTCHA.HELP"
[maxLength]="10"
[value]="value()"
(valueChange)="valueChange.emit($event)"
[error]="error()"
/>
|
- linha 9: [alt]: o que um leitor de tela lê (o [TalkBack] do [Android]) no lugar da imagem;
- linhas 13–16: "Outra imagem" emite o output [reload];
- linhas 18–25: o campo, que também é controlado pelo pai: o componente transmite o valor e quaisquer alterações dele.
11.12.12. src/app/components/confirmation.ts
| // =========================================================================
// src/app/components/confirmation.ts - "Tem certeza?"
// -------------------------------------------------------------------------
// Extraído do exemplo 16. Um serviço, que abre uma caixa de diálogo do Ionic
// (AlertController). A mensagem é uma CHAVE de tradução:
// if (await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM')) { ... }
// "Não, voltar" em vez de "Cancelar": a pergunta às vezes é "Cancelar esta
// consulta?", e um botão "Cancelar" ali seria ambíguo.
// Uma nova pergunta apaga as mensagens da ação anterior.
// =========================================================================
import { inject, Injectable } from '@angular/core';
import { AlertController } from '@ionic/angular';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';
@Injectable({ providedIn: 'root' })
export class Confirmation {
private readonly alerts = inject(AlertController);
private readonly messages = inject(Messages);
private readonly t = inject(Translations).t;
async ask(key: string): Promise<boolean> {
this.messages.clear();
const alert = await this.alerts.create({
// uma classe CSS para a caixa: sua largura (veja styles.scss)
cssClass: 'confirmation',
header: this.t('CONFIRMATION.TITLE'),
message: this.t(key),
buttons: [
// role 'cancel': o botão Não; um toque fora do diálogo ou o botão
// Voltar do celular dão o role 'backdrop': somente 'confirm' significa sim
{ text: this.t('CONFIRMATION.NO'), role: 'cancel' },
// cssClass: o botão vermelho (veja styles.scss)
{ text: this.t('CONFIRMATION.YES'), role: 'confirm', cssClass: 'danger-button' },
],
});
await alert.present();
// onDidDismiss: uma Promise, resolvida ao fechar, com o role do botão
const { role } = await alert.onDidDismiss();
return role === 'confirm';
}
}
|
A janela de confirmação do exemplo 16, usada assim: [if (await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM')) ...]. Um serviço, já que não tem nada para exibir por conta própria: é o [AlertController] do [Ionic] que cria a caixa de diálogo.
- Linha 24: uma nova pergunta limpa as mensagens da ação anterior;
- linha 27: uma classe CSS para a caixa: sua largura (veja [styles.scss]);
- Linhas 33–35: os botões. Tocar fora da caixa de diálogo, ou pressionar o botão Voltar do telefone, fecha a caixa de diálogo com o papel [backdrop] (veja o exemplo 16): somente "Sim, confirmar" ([confirm]) confirma;
- linhas 38–41: [present()] exibe a caixa de diálogo; [onDidDismiss()] retorna uma [Promise], resolvida ao fechar, com o papel do botão que foi tocado.
11.12.13. src/app/components/booking-dialog.ts
| // =========================================================================
// src/app/components/booking-dialog.ts - o conteúdo do diálogo para
// agendar um horário
// -------------------------------------------------------------------------
// O diálogo em si é um <ion-modal> da tela de agenda, aberto
// quando seu ENDEREÇO o pede (/schedule?...&book=7, veja
// pages/schedule.ts): o endereço descreve assim a tela inteira, diálogo incluído.
// Este componente é apenas seu CONTEÚDO.
//
// Ele não fala com o servidor: emite
// - confirm, com o paciente escolhido (undefined para um paciente que
// agenda para si mesmo);
// - close.
// É a tela de agenda que decide o que fazer com eles.
// =========================================================================
import { Component, inject, input, output, signal } from '@angular/core';
import { IonButton, IonSelect, IonSelectOption, SelectCustomEvent } from '@ionic/angular';
import { label, Person } from '../api/types';
import { Translations } from '../i18n/translations';
@Component({
selector: 'app-booking-dialog',
imports: [IonButton, IonSelect, IonSelectOption],
templateUrl: './booking-dialog.html',
styles: `
:host {
display: block;
padding: 20px;
}
h2 {
margin-top: 0;
font-size: 22px;
font-weight: 400;
}
.buttons {
display: flex;
justify-content: flex-end;
flex-wrap: wrap;
gap: 8px;
margin-top: 20px;
}
`,
})
export class BookingDialog {
readonly t = inject(Translations).t;
readonly label = label;
readonly timeRange = input.required<string>(); // "8:00 - 8:20"
// ADMIN / DOCTOR: os pacientes entre os quais escolher
readonly clients = input<Person[]>([]);
// USER: o paciente é o próprio usuário
readonly patient = input<string>();
readonly submitting = input(false);
readonly confirm = output<number | undefined>();
readonly close = output<void>();
// o paciente escolhido na lista
readonly clientId = signal<number | undefined>(undefined);
choose(event: SelectCustomEvent<number>): void {
this.clientId.set(event.detail.value);
}
}
|
O conteúdo da janela de agendamento de consulta. A própria janela é um [ion-modal] da tela do calendário, aberto quando seu endereço o solicita ([&book=7], veja [schedule.html]).
- Linhas 49–56: o componente não se comunica com o servidor: ele recebe o que exibe e envia duas respostas — uma para confirmar (com o paciente selecionado) e outra para fechar a janela. Quando um paciente agenda uma consulta para si mesmo, ele recebe seu próprio nome ([patient]) e nenhuma lista;
- Linha 59: o paciente selecionado na lista: o estado da janela.
11.12.14. src/app/components/booking-dialog.html
| <!-- ======================================================================
booking-dialog.html - o conteúdo do diálogo de reserva
====================================================================== -->
<h2>{{ t('BOOKING_DIALOG.TITLE') }}</h2>
<p>{{ t('BOOKING_DIALOG.SLOT', { time: timeRange() }) }}</p>
<!-- um paciente reserva para si mesmo: sem lista (e o servidor
ignoraria qualquer clientId de todo modo) -->
@if (patient(); as patient) {
<p>{{ t('BOOKING_DIALOG.PATIENT_LABEL') }}: <strong>{{ patient }}</strong></p>
} @else {
<!-- placeholder: o texto exibido enquanto nenhum paciente for escolhido -->
<ion-select
[label]="t('BOOKING_DIALOG.PATIENT_LABEL')"
fill="outline"
labelPlacement="stacked"
interface="popover"
[placeholder]="t('BOOKING_DIALOG.CHOOSE_PATIENT')"
[value]="clientId()"
(ionChange)="choose($event)"
>
@for (c of clients(); track c.id) {
<ion-select-option [value]="c.id">{{ label(c) }}</ion-select-option>
}
</ion-select>
}
<div class="buttons">
<ion-button fill="clear" (click)="close.emit()">{{ t('BOOKING_DIALOG.CANCEL') }}</ion-button>
<ion-button [disabled]="submitting()" (click)="confirm.emit(clientId())">
{{ t('BOOKING_DIALOG.CONFIRM') }}
</ion-button>
</div>
|
- linhas 10–11: um paciente faz o agendamento para si mesmo: seu nome, sem lista;
- linhas 14–26: o ADMIN ou o médico seleciona o paciente em uma lista suspensa; [placeholder]: o texto exibido enquanto nenhum paciente estiver selecionado;
- linhas 29–34: os botões, alinhados à direita; "Confirmar" fica desativado durante o envio.
11.13. As telas
Cada tela é um componente, carregado sob demanda pelo roteador (veja [app.routes.ts]), cujo template começa com [ion-content]: a área de rolagem, entre a barra superior e a área de erro do layout.
11.13.1. src/app/pages/login.ts
| // =========================================================================
// src/app/pages/login.ts - a tela de login (/login)
// -------------------------------------------------------------------------
// Mesma tela dos outros clientes: login, senha, captcha e
// um segundo botão "Criar uma conta de paciente" que verifica o MESMO captcha
// antes de abrir a criação de conta.
//
// /login?login=jbernard: o campo de login é preenchido previamente (logo após a
// criação de uma conta).
// Após um login bem-sucedido, esta tela NÃO navega por conta própria: a
// sessão muda, os guards do roteador são reavaliados (veja app.ts), e
// é o guard que sai da tela de login (para ?redirect=... ou para
// a página inicial do papel, veja app.routes.ts).
// =========================================================================
import { Component, inject, input, linkedSignal, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, ViewWillEnter } from '@ionic/angular';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { Captcha } from '../api/types';
import { CaptchaField } from '../components/captcha-field';
import { InputField } from '../components/input-field';
import { FormSubmission } from '../components/form-submission';
import { Messages } from '../state/messages';
import { Session } from '../state/session';
import { Translations } from '../i18n/translations';
// as contas de demonstração
const demoAccounts = [
{ accounts: 'admin', key: 'LOGIN.DEMO_ADMIN' },
{ accounts: 'pelissier, tatou, dupont', key: 'LOGIN.DEMO_DOCTOR' },
{ accounts: 'martin, durand, bistrou, german', key: 'LOGIN.DEMO_USER' },
];
@Component({
selector: 'app-login',
imports: [IonContent, IonButton, InputField, CaptchaField],
templateUrl: './login.html',
})
export class LoginPage implements ViewWillEnter {
private readonly api = inject(RdvMedecinsApi);
private readonly session = inject(Session);
private readonly router = inject(Router);
private readonly messages = inject(Messages);
readonly t = inject(Translations).t;
readonly submission = new FormSubmission(this.messages);
readonly demoAccounts = demoAccounts;
// o login do endereço (?login=...), entregue pelo roteador
// (withComponentInputBinding, veja main.ts)
readonly login = input<string>();
// o formulário: um signal VINCULADO ao input login. Ele começa com ele (30
// caracteres no máximo), pode ser modificado depois, e recomeça a partir dele se
// o endereço mudar
readonly form = linkedSignal(() => ({ login: (this.login() ?? '').slice(0, 30), password: '', captcha: '' }));
readonly captcha = signal<Captcha | null>(null);
// ionViewWillEnter: chamado pelo Ionic cada vez que a tela está prestes a
// ser exibida (na primeira vez, e ao voltar a ela)
ionViewWillEnter(): void {
void this.reloadCaptcha();
}
// uma nova imagem: ela é necessária após CADA tentativa, porque uma imagem só é
// usada UMA VEZ (o servidor a esquece assim que a verifica)
async reloadCaptcha(): Promise<void> {
try {
this.captcha.set(await this.api.captcha());
} catch {
this.captcha.set(null); // servidor inacessível: o login falhará com uma mensagem clara
}
}
update(field: 'login' | 'password' | 'captcha', value: string): void {
// um NOVO objeto: o signal muda de valor
this.form.update((f) => ({ ...f, [field]: value }));
this.submission.clearError(field);
}
// os dois botões compartilham esta sequência: envio e, em caso de falha,
// mensagem de erro e NOVA imagem
private async attempt(action: () => Promise<void>): Promise<void> {
this.messages.clear();
const succeeded = await this.submission.submit(action);
if (!succeeded) {
this.form.update((f) => ({ ...f, captcha: '' }));
await this.reloadCaptcha();
}
}
// em caso de sucesso, nada mais a fazer aqui: o guard muda a tela
logIn(): Promise<void> {
const f = this.form();
return this.attempt(() => this.session.logIn(f.login.trim(), f.password, this.captcha()?.id ?? '', f.captcha));
}
createAccount(): Promise<void> {
return this.attempt(async () => {
await this.api.registrationAccess(this.captcha()?.id ?? '', this.form().captcha);
await this.router.navigateByUrl('/register');
});
}
}
|
A tela de login.
- linhas 29–33: as contas de demonstração, exibidas abaixo do formulário;
- linhas 41–47: os serviços (recebidos via [inject()]), o envio do formulário e as contas de demonstração;
- linha 51: o login do endereço ([/login?login=jbernard], após criar uma conta), atribuído a este input pelo roteador;
- linha 55: o input: um objeto (nome do campo → valor) em um [linkedSignal]: um valor modificável, mas VINCULADO a um cálculo. Ele COMEÇA com o valor calculado (o login do endereço, até 30 caracteres); pode ser modificado depois, e o cálculo recomeça se o input [login] mudar. Não é possível ler um input durante a inicialização de um campo (ele ainda não recebeu seu valor): o [linkedSignal] resolve esse problema;
- linha 56: o CAPTCHA recebido (seu ID e sua imagem);
- linhas 60–62: [ionViewWillEnter]: um método que o [Ionic] chama toda vez que a tela está prestes a ser exibida; na primeira vez E ao voltar para a tela (a tela, mantida na memória, não é recriada). Aqui, uma nova imagem é solicitada: a da visita anterior pode já ter sido usada;
- linhas 66–72: uma nova imagem, ao abrir a tela, sob demanda e após CADA tentativa (uma imagem é usada apenas uma vez);
- linhas 74–78: um campo modificado: um NOVO objeto ([{ ...f, [field]: value }]: uma cópia, na qual um campo muda), e o erro do campo desaparece. O parâmetro [field] aceita apenas os três nomes do input: um erro de digitação causaria um erro de compilação;
- linhas 82–89: os dois botões seguem esta sequência: envio e, se malsucedido, o CAPTCHA é limpo e uma nova imagem é exibida;
- linhas 92–95: o login. Se bem-sucedido, a tela não faz mais nada: a sessão muda, os guards são reavaliados e é o guard que sai da tela de login (veja [app.routes.ts]);
- linhas 97–102: "Criar uma conta de paciente": o servidor verifica o CAPTCHA e emite um token (um cookie); a tela de criação de conta é então aberta.
11.13.2. src/app/pages/login.html
| <!-- ======================================================================
login.html - a tela de login
====================================================================== -->
<ion-content class="ion-padding">
<h1>{{ t('LOGIN.TITLE') }}</h1>
<!-- autocomplete: o gerenciador de senhas do celular pode
preencher o formulário -->
<app-input-field
label="LOGIN.LOGIN_LABEL"
autocomplete="username"
[value]="form().login"
(valueChange)="update('login', $event)"
[error]="submission.errors()['login']"
/>
<app-input-field
label="LOGIN.PASSWORD_LABEL"
autocomplete="current-password"
[secret]="true"
[value]="form().password"
(valueChange)="update('password', $event)"
[error]="submission.errors()['password']"
/>
<app-captcha-field
[svg]="captcha()?.svg"
[value]="form().captcha"
(valueChange)="update('captcha', $event)"
(reload)="reloadCaptcha()"
[error]="submission.errors()['captcha']"
/>
<!-- expand="block": a largura total -->
<ion-button expand="block" shape="round" [disabled]="submission.inProgress()" (click)="logIn()">
{{ t('LOGIN.SUBMIT') }}
</ion-button>
<ion-button expand="block" shape="round" fill="outline" [disabled]="submission.inProgress()" (click)="createAccount()">
{{ t('LOGIN.CREATE_ACCOUNT') }}
</ion-button>
<p class="ion-text-center help">{{ t('LOGIN.CREATE_ACCOUNT_HELP') }}</p>
<!-- as contas de demonstração -->
<div class="demo">
<div>{{ t('LOGIN.DEMO_ACCOUNTS') }}</div>
@for (d of demoAccounts; track d.key) {
<div>• <code>{{ d.accounts }}</code> - {{ t(d.key) }}</div>
}
</div>
</ion-content>
|
- linhas 10–24: o nome de usuário e a senha. [autocomplete]: o gerenciador de senhas do telefone os preenche e se oferece para salvar a conta após o login;
- linhas 25–31: o CAPTCHA; sua imagem é enviada do servidor após a tela ser exibida: [captcha()?.svg] equivale a [undefined] até lá;
- linhas 34–39: os dois botões, ocupando toda a largura ([expand="block"]), ficam desativados durante o envio;
- linhas 43–48: as contas de demonstração: um laço [@for] (veja o exemplo 03) sobre o array [login.ts]; [track d.key]: que identifica cada elemento.
11.13.3. src/app/pages/schedule.ts
| // =========================================================================
// src/app/pages/schedule.ts - a tela de agenda (/schedule)
// -------------------------------------------------------------------------
// Três blocos, como nos outros clientes:
// 1. a escolha do médico e do dia;
// 2. a agenda desse médico nesse dia;
// 3. o diálogo para agendar um horário (um <ion-modal>).
//
// TODO o estado da tela está em seu ENDEREÇO:
// /schedule?doctorId=1&day=2026-10-05 a agenda
// /schedule?doctorId=1&day=2026-10-05&book=7 + o diálogo de agendamento
// O roteador entrega esses três parâmetros aos inputs do componente
// (withComponentInputBinding); a tela DEDUZ deles o que exibe (signals
// computed), e as ações do usuário mudam o endereço.
// Na web, é possível portanto recarregar a página, salvá-la nos favoritos,
// usar Voltar / Avançar; no celular, o botão Voltar fecha
// o diálogo de agendamento.
//
// O que cada um vê e pode fazer é decidido pelo SERVIDOR (campos
// patient, mine, bookable, appointmentId de cada horário): a tela apenas
// o exibe. Um paciente nem sequer recebe os nomes dos outros pacientes.
// =========================================================================
import { Location } from '@angular/common';
import { Component, computed, effect, inject, input, linkedSignal, resource, signal } from '@angular/core';
import { Router } from '@angular/router';
import {
DatetimeCustomEvent, IonButton, IonCard, IonCardContent, IonCardHeader, IonCardSubtitle, IonCardTitle, IonContent,
IonDatetime, IonIcon, IonItem, IonLabel, IonList, IonModal, IonSelect, IonSelectOption, IonSpinner,
SelectCustomEvent,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { calendarOutline } from 'ionicons/icons';
import { ApiError } from '../api/api-error';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { ScheduleSlot, label } from '../api/types';
import { positiveInteger } from '../app.routes';
import { Confirmation } from '../components/confirmation';
import { BookingDialog } from '../components/booking-dialog';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { isManager, isPatient, Session } from '../state/session';
import { today, isValidDate, timeRange, longDay } from '../formatting';
import { Translations } from '../i18n/translations';
// o endereço da agenda (sem o diálogo de agendamento, ou com ele)
export function scheduleUrl(doctorId: number | undefined, day: string, book?: number): string {
const params = new URLSearchParams({ doctorId: String(doctorId ?? ''), day });
if (book !== undefined) params.set('book', String(book));
return `/schedule?${params}`;
}
@Component({
selector: 'app-schedule',
imports: [
IonContent, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonCardSubtitle, IonSelect, IonSelectOption,
IonItem, IonLabel, IonIcon, IonButton, IonList, IonSpinner, IonModal, IonDatetime, BookingDialog,
],
templateUrl: './schedule.html',
styleUrl: './schedule.scss',
})
export class SchedulePage {
private readonly api = inject(RdvMedecinsApi);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
private readonly location = inject(Location);
private readonly confirmation = inject(Confirmation);
private readonly translations = inject(Translations);
readonly t = this.translations.t;
readonly user = inject(Session).user;
readonly timeRange = timeRange;
readonly label = label;
// os parâmetros do endereço, como estão (textos, possivelmente inválidos)
readonly doctorId = input<string>();
readonly day = input<string>();
readonly book = input<string>();
// o que é deduzido deles: signals COMPUTED (computed), recalculados quando
// o endereço muda
readonly urlDoctorId = computed(() => positiveInteger(this.doctorId()));
private readonly bookId = computed(() => positiveInteger(this.book()));
// o dia: o do endereço se for válido, senão hoje
readonly invalidDay = computed(() => {
const day = this.day();
return day !== undefined && !isValidDate(day);
});
readonly shownDay = computed(() => (this.invalidDay() ? today() : (this.day() ?? today())));
// ------------------------------------------------ os dados
// resource: uma leitura assíncrona, descrita por signals. loader é
// chamado novamente cada vez que params muda; um params undefined: nada a ler
readonly doctors = resource({
loader: () => this.cache.read('doctors', () => this.api.list('doctors')),
});
// os pacientes: somente para quem tem o direito de lê-los (diálogo de agendamento)
readonly clients = resource({
params: () => (isManager(this.user()) ? true : undefined),
loader: () => this.cache.read('clients', () => this.api.list('clients')),
});
// sem um médico no endereço, um DOCTOR vê a SUA agenda (o servidor
// a encontra a partir do token); os demais não veem nada
readonly schedule = resource({
params: () => {
const id = this.urlDoctorId();
if (this.invalidDay() || (id === undefined && this.user()?.role !== 'DOCTOR')) return undefined;
return { id, day: this.shownDay() };
},
loader: ({ params: { id, day } }) => this.cache.read(`schedule/${id}/${day}`, () => this.api.schedule(id, day)),
});
// a agenda recebida (undefined: ainda não chegou, falhou, ou sem agenda)
readonly s = computed(() => (this.schedule.hasValue() ? this.schedule.value() : undefined));
// o médico exibido: o do endereço, ou o da agenda recebida (DOCTOR)
readonly shownDoctorId = computed(() => this.urlDoctorId() ?? this.s()?.doctor.id);
// o horário cujo diálogo de agendamento está aberto (&book=7),
// somente se puder ser agendado por este usuário
readonly toBook = computed(() => this.s()?.slots.find((c) => c.id === this.bookId() && c.bookable));
// paciente que já tem uma consulta futura: por que não há botão
// "Agendar"; inútil na agenda que contém essa consulta
readonly info = computed(() => {
const s = this.s();
return s?.info && !s.slots.some((c) => c.mine) ? s.info : undefined;
});
// USER: o nome do paciente, exibido no diálogo de agendamento
readonly patient = computed(() => {
const u = this.user();
return isPatient(u) ? u?.name : undefined;
});
// ------------------------------------------------ 1. a escolha do médico e do dia
// um pequeno formulário, cujo estado só é usado antes de enviar. linkedSignal:
// ele COMEÇA com os valores do endereço, e volta a eles quando este muda
readonly doctorChoice = linkedSignal(() => this.shownDoctorId());
readonly dayChoice = linkedSignal(() => this.shownDay());
readonly calendarOpen = signal(false);
// o idioma do calendário (ion-datetime): 'fr-FR' ou 'en-US'
readonly locale = computed(() => (this.translations.language() === 'fr' ? 'fr-FR' : 'en-US'));
// o médico escolhido deve estar na lista (senão: nenhum)
readonly knownId = computed(() => {
const id = this.doctorChoice();
const list = this.doctors.hasValue() ? this.doctors.value() : [];
return list.some((d) => d.id === id) ? id : undefined;
});
readonly submitting = signal(false);
// true se o diálogo foi aberto pelo botão "Agendar" desta tela
private openedHere = false;
constructor() {
addIcons({ calendarOutline });
// dados invalidados (agendamento, cancelamento): eles são lidos novamente
reloadAfterInvalidation(this.doctors, this.clients, this.schedule);
// uma leitura que falhou: sua mensagem, na parte inferior da tela
reportErrors(this.doctors, this.clients, this.schedule);
// um dia inválido no endereço: uma mensagem, exibida DEPOIS do fim da
// navegação atual (setTimeout), que apaga as mensagens da
// tela anterior (veja app.ts)
effect(() => {
if (this.invalidDay()) setTimeout(() => this.messages.showError('ERRORS.INVALID_DATE'));
});
}
longDay(day: string): string {
return longDay(day, this.translations.language());
}
chooseDoctor(event: SelectCustomEvent<number>): void {
this.doctorChoice.set(event.detail.value);
}
// o calendário: "2026-10-05" (ou "2026-10-05T00:00:00") -> "2026-10-05"
chooseDay(event: DatetimeCustomEvent): void {
const value = event.detail.value;
if (typeof value === 'string') this.dayChoice.set(value.slice(0, 10));
this.calendarOpen.set(false);
}
// "Ver agenda" muda o endereço; o roteador REAPROVEITA este componente
// (mesma rota): apenas seus inputs mudam, e tudo é recalculado
view(): void {
void this.router.navigateByUrl(scheduleUrl(this.knownId(), this.dayChoice()));
}
// "Agendar" muda o ENDEREÇO (&book=...): o diálogo abre
openBooking(c: ScheduleSlot): void {
this.openedHere = true;
void this.router.navigateByUrl(scheduleUrl(this.shownDoctorId(), this.shownDay(), c.id));
}
// fechar o diálogo: voltar ao endereço anterior
closeBooking(): void {
// o endereço já não tem mais &book= (botão Voltar do navegador): nada a fazer
if (this.bookId() === undefined) return;
if (this.openedHere) {
// como o botão Voltar: o endereço com &book= é removido do histórico
this.openedHere = false;
this.location.back();
} else {
// tela aberta diretamente neste endereço: ele é substituído
void this.router.navigateByUrl(scheduleUrl(this.shownDoctorId(), this.shownDay()), { replaceUrl: true });
}
}
// o servidor é a referência: após cada ação, a agenda é lida novamente
// (e a área do paciente, que mostra sua consulta). A invalidação
// notifica todas as telas de agenda vivas, inclusive esta
private reload(): void {
this.cache.invalidate('my-area');
this.cache.invalidate('schedule');
}
async confirmBooking(slot: ScheduleSlot, clientId: number | undefined): Promise<void> {
const manager = isManager(this.user());
this.submitting.set(true);
try {
await this.api.book(this.shownDay(), slot.id, manager ? clientId : undefined);
this.messages.flash({ key: 'SCHEDULE.BOOKED' });
} catch (e) {
if (!(e instanceof ApiError)) throw e;
if (e.key === 'ERRORS.CHOOSE_PATIENT') {
// nenhum paciente escolhido: o diálogo permanece aberto
this.messages.showError(e.key);
return; // (finally é executado de qualquer maneira)
}
// horário ocupado nesse meio-tempo, paciente que já tem uma consulta...: a
// mensagem será exibida na agenda, com o diálogo fechado
this.messages.flash({ success: false, key: e.key, params: e.params });
} finally {
this.submitting.set(false);
}
this.closeBooking();
this.reload();
}
async cancel(c: ScheduleSlot): Promise<void> {
if (c.appointmentId === null || !(await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM'))) return;
try {
await this.api.cancelAppointment(c.appointmentId);
this.messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
this.messages.showApiError(e);
}
this.reload();
}
goToMyArea(): void {
void this.router.navigateByUrl('/my-area');
}
}
|
A tela mais rica em funcionalidades: seleção de um médico e de um dia, o calendário e a janela de agendamento.
- linhas 47–51: o endereço do calendário. TODO o estado da tela está contido em seu endereço; as ações do usuário o alteram, e a tela determina o que exibir com base nele;
- linhas 76–78: os três parâmetros do endereço, fornecidos aos inputs pelo roteador. São strings, tal como estão: podem estar ausentes ou ser inválidos;
- linhas 82–89: o que deriva deles: signals CALCULADOS, recalculados quando o endereço muda. A data do endereço, se válida; caso contrário, hoje;
- linhas 94–96: [resource()]: uma leitura assíncrona, descrita por signals (é o [FutureBuilder] do [Flutter], mas melhor). Sua função [loader] retorna uma [Promise]; o resource expõe signals: [value()], [isLoading()], [error()], [status()]... Os médicos são lidos do cache: uma vez para toda a sessão;
- Linhas 98–101: [params]: um cálculo do qual o resource depende. Toda vez que seu valor muda, [loader] é chamado com esse novo valor; se for igual a [undefined], não há nada a ler. Aqui: os pacientes, somente se o usuário tiver permissão para vê-los (para a janela de agendamento);
- linhas 104–111: o calendário; seus parâmetros são o médico e o dia da consulta. "Ver agenda" altera o endereço; o roteador REAPROVEITA a tela (mesma rota) com novos inputs; [params] muda, e o calendário é relido, sem escrever mais nada (o cliente [Flutter] precisava de [didUpdateWidget]). Se não houver médico no endereço, um médico conectado vê a SUA agenda (o servidor a recupera usando o token); os demais não veem nada;
- linha 114: o calendário recebido. [hasValue()] primeiro: ler [value()] de um resource que falhou causaria um erro;
- linha 119: o horário da janela de agendamento é o do endereço ([&book=7]), somente se puder ser agendado POR ESTE USUÁRIO (um horário ocupado nesse meio-tempo, um endereço criado manualmente: nenhuma janela de agendamento);
- linhas 122–125: o servidor envia esta mensagem ([info]) junto com TODOS os calendários para um paciente que já tem uma consulta futura; mas no calendário que contém essa consulta (um horário [mine]), ela é desnecessária — e até enganosa — logo após um agendamento: o paciente vê sua consulta, listada sob seu nome, com um botão "Cancelar". Por isso, ela é exibida somente nos outros calendários. [some]: verdadeiro se pelo menos um elemento do array satisfizer a condição;
- linhas 135–136: seleção do médico e do dia: um pequeno formulário, cujo estado COMEÇA com os valores do endereço e VOLTA a eles quando o endereço muda (botão Voltar do navegador): dois [linkedSignal]. O cliente [Flutter] obtinha isso recriando o widget (sua chave mudava com o endereço);
- linha 139: o idioma do calendário, no formato esperado pelo [ion-datetime];
- linhas 141–145: o médico selecionado deve estar na lista (caso contrário: nenhum, e "Ver agenda" fica desativado);
- linhas 154–156: dados invalidados (agendamento, cancelamento): os três resources são relidos; se uma leitura falhar, uma mensagem aparece na parte inferior da tela (veja [cache.ts] e [messages.ts]);
- linhas 160–162: uma data inválida no endereço: uma mensagem. Ela é exibida DEPOIS do fim da navegação atual ([setTimeout]: quando todo o bloco de código atual e o código subsequente terminaram de ser executados); caso contrário, a passagem para a "nova página" (veja [app.ts]) a apagaria imediatamente;
- linhas 174–178: o dia selecionado no calendário; [ion-datetime] retorna uma data no formato ISO ("2026-10-05", às vezes seguida da hora);
- linhas 182–184: "Ver agenda" altera o endereço;
- linhas 187–190: "Agendar" também altera o endereço ([&book=...]): uma NOVA entrada é adicionada ao histórico de navegação; a janela de agendamento é aberta porque o endereço a exige. [openedHere] registra que esta tela a abriu;
- linhas 193–204: fechar a janela: voltar ao endereço anterior. Se esta tela a abriu, voltamos no histórico ([location.back()]), exatamente como o botão Voltar de um telefone ou o botão Voltar de um navegador. Se a tela foi aberta diretamente neste endereço (na web), não há nada atrás dela: substituímos o endereço pelo do calendário ([replaceUrl]). Se o endereço já não contém [&book=] (você acabou de voltar na navegação), não há nada a fazer;
- linhas 209–212: após um agendamento ou cancelamento, os dados do servidor prevalecem: o calendário (e a área do paciente) são invalidados; o cache notifica as telas de calendário, que são recarregadas;
- linhas 214–235: o agendamento. Se nenhum paciente estiver selecionado, a janela permanece aberta, exibindo a mensagem. Qualquer outra ação fecha a janela, e a mensagem (de sucesso ou de erro — como um horário ocupado nesse meio-tempo...) é uma mensagem flash que aparece quando o endereço volta ao do calendário;
- linhas 237–246: cancelamento, após confirmação.
11.13.4. src/app/pages/schedule.html
| <!-- ======================================================================
schedule.html - a tela de agenda
====================================================================== -->
<ion-content class="ion-padding">
<!-- 1. a escolha do médico e do dia -->
<ion-card class="picker">
<ion-card-content>
<ion-select
[label]="t('DOCTOR_DAY_PICKER.DOCTOR_LABEL')"
fill="outline"
labelPlacement="stacked"
interface="popover"
[placeholder]="t('DOCTOR_DAY_PICKER.CHOOSE_DOCTOR')"
[value]="knownId()"
(ionChange)="chooseDoctor($event)"
>
@if (doctors.hasValue()) {
@for (d of doctors.value(); track d.id) {
<ion-select-option [value]="d.id">{{ label(d) }}</ion-select-option>
}
}
</ion-select>
<!-- o dia: uma linha que se toca para abrir o calendário -->
<ion-item class="day" [button]="true" [detail]="false" lines="full" (click)="calendarOpen.set(true)">
<ion-label>
<p>{{ t('DOCTOR_DAY_PICKER.DAY_LABEL') }}</p>
<h3>{{ longDay(dayChoice()) }}</h3>
</ion-label>
<ion-icon slot="end" name="calendar-outline" [attr.aria-label]="t('DOCTOR_DAY_PICKER.CHOOSE_DAY')" />
</ion-item>
<ion-button expand="block" shape="round" [disabled]="knownId() === undefined" (click)="view()">
{{ t('DOCTOR_DAY_PICKER.VIEW_SCHEDULE') }}
</ion-button>
</ion-card-content>
</ion-card>
<!-- o calendário, em um diálogo; locale: o idioma dos nomes dos
dias e meses; showDefaultButtons: os botões Cancel / OK -->
<ion-modal class="dialog" [isOpen]="calendarOpen()" (didDismiss)="calendarOpen.set(false)">
<ng-template>
<ion-datetime
presentation="date"
[value]="dayChoice()"
[locale]="locale()"
[firstDayOfWeek]="1"
min="2020-01-01"
max="2035-12-31"
[showDefaultButtons]="true"
[cancelText]="t('BOOKING_DIALOG.CANCEL')"
doneText="OK"
(ionChange)="chooseDay($event)"
/>
</ng-template>
</ion-modal>
<!-- paciente que já tem uma consulta futura: por que não há botão "Agendar" -->
@if (info(); as info) {
<ion-card class="info">
<ion-item lines="none" color="none">
<ion-label class="ion-text-wrap">{{ t(info) }}</ion-label>
<ion-button slot="end" fill="clear" (click)="goToMyArea()">{{ t('APP.MENU_MY_AREA') }}</ion-button>
</ion-item>
</ion-card>
}
<!-- 2. a agenda -->
@if (s(); as s) {
<ion-card class="schedule">
<ion-card-header>
<ion-card-title>{{ t('SCHEDULE.TITLE_PREFIX') }} {{ longDay(s.day) }}</ion-card-title>
<ion-card-subtitle>{{ label(s.doctor) }}</ion-card-subtitle>
</ion-card-header>
@if (s.slots.length === 0) {
<ion-card-content>{{ t('SCHEDULE.NO_SLOTS') }}</ion-card-content>
}
<ion-list lines="full">
@for (c of s.slots; track c.id) {
<!-- os horários agendáveis são levemente coloridos -->
<ion-item [class.bookable]="c.bookable">
<div slot="start" class="time-range">{{ timeRange(c) }}</div>
<ion-label>
@if (c.free) {
<span class="tag free">{{ t('SCHEDULE.FREE') }}</span>
} @else if (c.patient) {
<span class="tag" [class.mine]="c.mine">{{ label(c.patient) }}</span>
} @else {
<span class="tag">{{ t('SCHEDULE.BOOKED_BY_OTHER') }}</span>
}
</ion-label>
<!-- os botões permitidos pelo SERVIDOR (bookable, appointmentId) -->
@if (c.bookable) {
<ion-button slot="end" fill="outline" shape="round" (click)="openBooking(c)">
{{ t('SCHEDULE.BOOK') }}
</ion-button>
} @else if (c.appointmentId !== null) {
<ion-button slot="end" fill="outline" shape="round" color="danger" (click)="cancel(c)">
{{ t('SCHEDULE.CANCEL_APPOINTMENT') }}
</ion-button>
}
</ion-item>
}
</ion-list>
</ion-card>
} @else if (schedule.isLoading()) {
<div class="ion-text-center ion-padding"><ion-spinner /></div>
} @else if (schedule.status() === 'idle') {
<p class="empty">{{ t('SCHEDULE.EMPTY_STATE') }}</p>
}
<!-- 3. o diálogo de reserva, aberto somente se o endereço contiver
&book=...; ele fecha (botão Voltar, toque fora dele...):
didDismiss -->
<ion-modal class="dialog" [isOpen]="toBook() !== undefined" (didDismiss)="closeBooking()">
<ng-template>
@if (toBook(); as slot) {
<app-booking-dialog
[timeRange]="timeRange(slot)"
[clients]="clients.hasValue() ? clients.value() : []"
[patient]="patient()"
[submitting]="submitting()"
(confirm)="confirmBooking(slot, $event)"
(close)="closeBooking()"
/>
}
</ng-template>
</ion-modal>
</ion-content>
|
- linhas 9–23: a lista de médicos; [labelPlacement="stacked"]: o rótulo permanece acima do campo, de modo que o texto "-- escolha um médico --" ([placeholder]) fique visível enquanto nenhum médico tiver sido selecionado. As opções aguardam a lista: [@if (doctors.hasValue())];
- linhas 25–31: o dia é exibido como um campo (com seu rótulo acima, a data por extenso e um ícone de calendário), em um [ion-item] em que você toca para abrir o calendário;
- linhas 32–34: "Ver agenda", desativado até que um médico conhecido seja selecionado;
- linhas 40–55: o calendário, [ion-datetime], em uma janela ([ion-modal]) aberta pelo signal [calendarOpen]. [presentation="date"]: apenas a data, sem a hora; [locale]: o idioma dos nomes dos dias e dos meses; [firstDayOfWeek]: a semana começa na segunda-feira; [showDefaultButtons]: os botões Cancelar / OK. "OK" envia [ionChange] com a data selecionada e depois fecha a janela; [didDismiss]: a janela foi fechada (OK, Cancelar, toque fora dela, botão Voltar);
- linhas 58–65: um paciente que já tem uma consulta futura: por que não há botão "Agendar" (veja [info], acima);
- linhas 68–104: o calendário. Uma linha por horário: a hora, um rótulo (disponível, o nome do paciente ou "Ocupado" para outro paciente) e o botão habilitado pelo SERVIDOR ([bookable], [appointmentId]). [@else if]: a continuação dos casos de um [@if];
- linhas 105–109: o calendário de consultas está carregando: uma roda giratória ([ion-spinner]); nenhum calendário a exibir (o resource está inativo, [idle]): um convite para selecionar um médico e uma data;
- linhas 114–127: a janela de agendamento, aberta ([isOpen]) somente se o endereço corresponder a um horário agendável. Ela também pode se fechar sozinha: pelo botão Voltar do telefone ou por um toque ao lado; [didDismiss] então chama [closeBooking], que valida o endereço. Seu conteúdo é um [ng-template]: ele só é criado na abertura e destruído no fechamento (o paciente selecionado é esquecido).
O cliente [Flutter] desenhava a janela de agendamento por conta própria (um [Stack], um fundo cinza, um cartão); [ion-modal] fornece tudo isso, junto com a animação de abertura e o tratamento do botão Voltar.
11.13.5. src/app/pages/schedule.scss
| // =========================================================================
// schedule.scss - os estilos da tela de agenda
// =========================================================================
ion-card {
margin: 0 0 12px;
}
// o dia: uma linha que se parece com os campos de entrada
ion-item.day {
--padding-start: 0;
--inner-padding-end: 0;
margin-bottom: 12px;
p {
font-size: 13px;
}
h3 {
font-size: 16px;
}
}
// a informação destinada ao paciente
ion-card.info {
--background: #e1f5fe;
}
ion-card.schedule ion-card-title {
font-size: 19px;
}
// os horários agendáveis: um fundo verde pálido
ion-item.bookable {
--background: #e8f5e9;
}
.time-range {
width: 96px;
font-size: 14px;
font-weight: 500;
}
// uma tag colorida (o "badge" dos outros clientes); cinza por padrão
.tag {
display: inline-block;
padding: 3px 8px;
border-radius: 6px;
color: white;
background: #757575;
font-size: 13px;
font-weight: bold;
white-space: normal;
&.free {
background: #388e3c;
}
&.mine {
background: var(--ion-color-primary);
}
}
.empty {
padding: 0 16px;
color: var(--ion-color-medium-shade);
}
|
Estilos da tela: visão do dia, informações do paciente (fundo azul claro), horários agendáveis (fundo verde claro), agenda e rótulos coloridos (linhas 45–62: cinza por padrão, verde para um horário disponível, índigo para a consulta do paciente conectado).
11.13.6. src/app/pages/persons-config.ts
| // =========================================================================
// src/app/pages/persons-config.ts - médicos ou clientes?
// -------------------------------------------------------------------------
// As telas de gerenciamento dos médicos e dos clientes são IDÊNTICAS: mesma
// lista, mesmo formulário. Elas são escritas UMA VEZ (persons.ts,
// person-form.ts); apenas o endereço da API e as
// chaves dos rótulos mudam, descritos aqui. O roteador passa o tipo a cada tela.
// =========================================================================
import { PersonType } from '../api/rdvmedecins-api';
import { Person } from '../api/types';
export interface PersonKeys {
title: string; // "Médicos"
add: string; // "Adicionar um médico"
edit: string; // "Editar um médico"
empty: string; // "Nenhum médico."
confirmDelete: string;
added: string; // "O médico {{name}} foi adicionado (login: {{login}})."
edited: string;
deleted: string;
notFound: string; // o registro foi excluído nesse meio-tempo
}
// Record<PersonType, ...>: um objeto que tem EXATAMENTE uma propriedade por
// tipo (o compilador verifica que nenhuma foi esquecida)
const allKeys: 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',
notFound: 'ERRORS.DOCTOR_NOT_FOUND',
},
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',
notFound: 'ERRORS.PATIENT_NOT_FOUND',
},
};
export const keys = (type: PersonType): PersonKeys => allKeys[type];
// {{name}} e {{login}} das mensagens de "adicionado / editado / excluído"
export const messageParams = (p: Person): Record<string, string> => ({
name: `${p.firstName} ${p.lastName}`,
login: p.login ?? '',
});
|
As telas de médicos e de clientes são idênticas; apenas as chaves de rótulo, descritas aqui, diferem.
- linhas 13–23: chaves para um tipo de "pessoa", descritas por uma interface;
- linhas 27–50: [Record<PersonType, PersonKeys>]: um objeto que tem EXATAMENTE uma propriedade por tipo de pessoa. Adicionar um valor a [PersonType] causaria um erro de compilação aqui, enquanto suas chaves não forem definidas;
- linhas 55–58: os parâmetros das mensagens de "adicionado", "modificado" e "excluído".
11.13.7. src/app/pages/persons.ts
| // =========================================================================
// src/app/pages/persons.ts - a lista dos médicos OU dos clientes (ADMIN)
// -------------------------------------------------------------------------
// Uma única tela para ambos: o tipo (médicos ou clientes) chega como
// input (a propriedade data da rota, veja app.routes.ts); os rótulos
// específicos de cada um estão em persons-config.ts.
// Em um celular, uma tabela de cinco colunas não cabe: uma linha de lista
// por pessoa (nome, login), com seus dois botões; o botão redondo
// "+" (<ion-fab>) adiciona uma pessoa.
// =========================================================================
import { Component, computed, inject, input, resource } from '@angular/core';
import { Router } from '@angular/router';
import {
IonButton, IonCard, IonContent, IonFab, IonIcon, IonItem, IonLabel, IonSpinner,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { add, createOutline, trashOutline } from 'ionicons/icons';
import { RdvMedecinsApi, PersonType } from '../api/rdvmedecins-api';
import { label, Person } from '../api/types';
import { Confirmation } from '../components/confirmation';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { Translations } from '../i18n/translations';
import { keys, messageParams } from './persons-config';
@Component({
selector: 'app-persons',
imports: [IonContent, IonCard, IonItem, IonLabel, IonButton, IonIcon, IonFab, IonSpinner],
templateUrl: './persons.html',
styleUrl: './persons.scss',
})
export class PersonsPage {
private readonly api = inject(RdvMedecinsApi);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
private readonly confirmation = inject(Confirmation);
readonly t = inject(Translations).t;
readonly label = label;
readonly type = input.required<PersonType>();
readonly c = computed(() => keys(this.type()));
// a lista, vinda do cache; params: o tipo (o roteador poderia
// reaproveitar a tela para o outro tipo, /doctors -> /clients)
readonly list = resource({
params: () => this.type(),
loader: ({ params: type }) => this.cache.read(type, () => this.api.list(type)),
});
constructor() {
addIcons({ add, createOutline, trashOutline });
reloadAfterInvalidation(this.list);
reportErrors(this.list);
}
// "Mme Marie PELISSIER" -> "MP"
initials(p: Person): string {
return `${p.firstName.charAt(0)}${p.lastName.charAt(0)}`;
}
add(): void {
void this.router.navigateByUrl(`/${this.type()}/add`);
}
edit(p: Person): void {
void this.router.navigateByUrl(`/${this.type()}/${p.id}/edit`);
}
async remove(p: Person): Promise<void> {
const c = this.c();
if (!(await this.confirmation.ask(c.confirmDelete))) return;
try {
await this.api.remove(this.type(), p.id);
this.messages.showSuccess(c.deleted, messageParams(p));
} catch (e) {
// um médico que ainda tem consultas: 409 ERRORS.DOCTOR_HAS_APPOINTMENTS
this.messages.showApiError(e);
}
// a lista é lida novamente (reloadAfterInvalidation)
this.cache.invalidate(this.type());
}
}
|
A lista de médicos ou de clientes.
- linha 42: o tipo (médicos ou clientes): a propriedade [data] da rota, atribuída a este input;
- linhas 47–50: a lista, vinda do cache. Se o roteador reaproveitasse a tela para o outro tipo, [params] mudaria, e a outra lista seria lida;
- linhas 63–69: adicionar e editar abrem o formulário por meio de seu endereço;
- linhas 71–83: exclusão, após confirmação. Um médico com consultas existentes é rejeitado pelo servidor (409 [DOCTOR_HAS_APPOINTMENTS]). Em todos os casos, a lista é invalidada e relida.
11.13.8. src/app/pages/persons.html
| <!-- ======================================================================
persons.html - a lista de médicos ou de clientes
====================================================================== -->
<ion-content class="ion-padding">
<h1>{{ t(c().title) }}</h1>
@if (list.hasValue()) {
@for (p of list.value(); track p.id) {
<ion-card>
<ion-item lines="none">
<!-- as iniciais, em um círculo -->
<div slot="start" class="initials">{{ initials(p) }}</div>
<ion-label>
<h2>{{ label(p) }}</h2>
<p class="login">{{ p.login }}</p>
</ion-label>
<ion-button slot="end" fill="clear" color="medium" [title]="t('PERSONS.EDIT')" (click)="edit(p)">
<ion-icon slot="icon-only" name="create-outline" />
</ion-button>
<ion-button slot="end" fill="clear" color="danger" [title]="t('PERSONS.DELETE')" (click)="remove(p)">
<ion-icon slot="icon-only" name="trash-outline" />
</ion-button>
</ion-item>
</ion-card>
} @empty {
<p>{{ t(c().empty) }}</p>
}
} @else if (list.isLoading()) {
<!-- ainda não carregada (ou o carregamento falhou: a mensagem está na parte inferior da tela) -->
<div class="ion-text-center ion-padding"><ion-spinner /></div>
}
<!-- ion-fab: um botão flutuante, fixo (slot="fixed") no canto inferior direito,
acima da lista rolante -->
<ion-fab slot="fixed" vertical="bottom" horizontal="end">
<ion-button shape="round" size="large" class="extended-fab" (click)="add()">
<ion-icon slot="start" name="add" />
{{ t(c().add) }}
</ion-button>
</ion-fab>
</ion-content>
|
- linhas 9–28: um cartão por pessoa: suas iniciais em um círculo, seu nome, seu login e seus dois botões. Uma tabela de cinco colunas, como a dos clientes web, não caberia em um telefone. [@empty]: o que um [@for]exibe quando a tabela está vazia;
- linhas 36–41: [ion-fab]: um botão flutuante, ancorado no canto inferior direito ([slot="fixed"]: ele não rola com a lista), "+ Adicionar um médico". O [FloatingActionButton.extended] do [Flutter] (um ícone e um texto) não tem equivalente pronto no [Ionic] ([ion-fab-button] é redondo, apenas para um ícone): um botão arredondado padrão é colocado em [ion-fab].
11.13.9. src/app/pages/persons.scss
| // =========================================================================
// persons.scss - os estilos da lista dos médicos ou dos clientes
// =========================================================================
ion-card {
margin: 0 0 10px;
}
// as iniciais, em um círculo colorido
.initials {
width: 44px;
height: 44px;
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
background: #dde3fb;
color: var(--ion-color-primary);
font-weight: 500;
}
.login {
font-family: 'Roboto Mono', monospace;
}
// um pouco de espaço na parte inferior, para não esconder a última linha sob o botão flutuante
ion-content {
--padding-bottom: 96px;
}
// um botão flutuante "estendido": ícone e texto, sobre um fundo claro
.extended-fab {
--background: #dde3fb;
--color: var(--ion-color-primary);
--border-radius: 16px;
text-transform: none;
}
|
As iniciais em um círculo, o texto do login em fonte monoespaçada, espaço abaixo da lista (linhas 27–29: caso contrário, o botão flutuante esconderia o último cartão) e o botão flutuante "expandido".
11.13.10. src/app/pages/person-form.ts
| // =========================================================================
// src/app/pages/person-form.ts - criação OU atualização de um
// médico ou de um cliente (ADMIN)
// -------------------------------------------------------------------------
// /doctors/add -> criação (sem id)
// /doctors/3/edit -> atualização (id = 3)
// (e os mesmos endereços sob /clients).
//
// Em uma atualização, a tela primeiro lê o registro; o formulário só é
// exibido depois que o registro foi lido, e COMEÇA com seus valores (um
// linkedSignal, sem precisar copiá-los depois).
// Nenhuma regra é verificada aqui: o servidor valida tudo, e seus erros
// são exibidos sob os campos (veja components/form-submission.ts).
// A VERSÃO lida com o registro volta com a atualização: se outro
// ADMIN o modificou nesse meio-tempo, o servidor responde 409 CONCURRENT_UPDATE.
// =========================================================================
import { Component, computed, effect, inject, input, linkedSignal, resource, untracked } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, IonSpinner } from '@ionic/angular';
import { ApiError } from '../api/api-error';
import { Data, RdvMedecinsApi, PersonType } from '../api/rdvmedecins-api';
import { positiveInteger } from '../app.routes';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { FormSubmission } from '../components/form-submission';
import { Cache } from '../state/cache';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';
import { keys, messageParams } from './persons-config';
const empty: Data = { title: 'Mr', firstName: '', lastName: '', login: '', password: '' };
@Component({
selector: 'app-person-form',
imports: [IonContent, IonButton, IonSpinner, InputField, PersonFields],
templateUrl: './person-form.html',
})
export class PersonFormPage {
private readonly api = inject(RdvMedecinsApi);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
readonly t = inject(Translations).t;
readonly submission = new FormSubmission(this.messages);
// o tipo: a propriedade data da rota; o id: o parâmetro :id do
// endereço (ausente em uma criação; sua validade é verificada pela rota)
readonly type = input.required<PersonType>();
readonly id = input<string>();
readonly recordId = computed(() => positiveInteger(this.id()));
readonly creating = computed(() => this.recordId() === undefined);
readonly c = computed(() => keys(this.type()));
// atualização: o registro é lido (incluindo sua versão), SEM cache: ele
// deve estar atualizado (senão o formulário começaria com uma versão
// desatualizada: 409 CONCURRENT_UPDATE)
readonly record = resource({
params: () => {
const id = this.recordId();
return id === undefined ? undefined : { type: this.type(), id };
},
loader: ({ params: { type, id } }) => this.api.read(type, id),
});
// uma CÓPIA modificável dos valores iniciais (o registro lido, ou vazio)
readonly form = linkedSignal<Data>(() => {
if (!this.record.hasValue()) return { ...empty };
const p = this.record.value();
return { title: p.title, firstName: p.firstName, lastName: p.lastName, login: p.login ?? '', password: '', version: p.version };
});
// o formulário é exibido para uma criação, ou depois que o registro foi lido
readonly ready = computed(() => this.creating() || this.record.hasValue());
constructor() {
// registro que não existe (excluído nesse meio-tempo...): volta para a lista
effect(() => {
const e = this.record.error();
if (e instanceof ApiError) {
untracked(() => {
this.messages.flash({ success: false, key: e.key, params: e.params });
void this.router.navigateByUrl(`/${this.type()}`);
});
}
});
}
text(field: string): string {
return String(this.form()[field] ?? '');
}
update(field: string, value: string): void {
this.form.update((f) => ({ ...f, [field]: value }));
this.submission.clearError(field);
}
back(): void {
void this.router.navigateByUrl(`/${this.type()}`);
}
async save(): Promise<void> {
const type = this.type();
const c = this.c();
const id = this.recordId();
const succeeded = await this.submission.submit(async () => {
const p = id === undefined
? await this.api.add(type, this.form())
: await this.api.edit(type, id, this.form());
this.messages.flash({ key: this.creating() ? c.added : c.edited, params: messageParams(p) });
});
const key = this.messages.error()?.key;
if (succeeded) {
this.cache.invalidate(type); // a lista mudou
this.back();
} else if (key === c.notFound) {
// excluído nesse meio-tempo por outro ADMIN: volta para a lista
this.messages.flash({ success: false, key });
this.back();
}
}
}
|
Adição ou edição de um médico ou de um cliente.
- linhas 49–53: o tipo ([data] da rota) e o identificador (o parâmetro [:id] do endereço, que está ausente em uma adição);
- linhas 58–64: em uma modificação, o registro é lido SEM o cache: ele deve estar atualizado. Em uma adição, [params] é igual a [undefined]: nada a ler;
- linhas 67–71: o input COMEÇA com os valores do registro (ou valores vazios) depois que o registro foi lido: outro [linkedSignal]. O cliente [Flutter] conseguia isso com dois widgets (o segundo criado depois que o registro foi lido);
- linha 74: o formulário só é exibido durante a criação ou depois que o registro foi lido;
- linhas 78–86: um registro não encontrado (excluído nesse meio-tempo): volta-se à lista, com uma mensagem;
- linhas 102–121: gravação do registro: [POST] ou [PUT], conforme haja ou não um ID. A mensagem de sucesso é uma mensagem flash: ela aparecerá na lista. Se um registro foi excluído nesse meio-tempo por outro ADMIN: volta-se à lista.
11.13.11. src/app/pages/person-form.html
| <!-- ======================================================================
person-form.html - criação ou atualização de uma pessoa
====================================================================== -->
<ion-content class="ion-padding">
<h1>{{ t(creating() ? c().add : c().edit) }}</h1>
@if (ready()) {
<app-person-fields
[values]="form()"
[errors]="submission.errors()"
(fieldChange)="update($event.field, $event.value)"
/>
<h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
<app-input-field
label="PERSONS.LOGIN_LABEL"
[maxLength]="30"
[value]="text('login')"
(valueChange)="update('login', $event)"
[error]="submission.errors()['login']"
[help]="creating() ? 'PERSONS.LOGIN_HELP_CREATE' : 'PERSONS.LOGIN_HELP_EDIT'"
/>
<!-- nunca preenchido previamente: a senha nunca volta do servidor -->
<app-input-field
label="PERSONS.PASSWORD_LABEL"
[secret]="true"
[maxLength]="72"
[value]="text('password')"
(valueChange)="update('password', $event)"
[error]="submission.errors()['password']"
[params]="submission.params()"
[help]="creating() ? 'PERSONS.PASSWORD_HELP_CREATE' : 'PERSONS.PASSWORD_HELP_EDIT'"
/>
<div class="buttons">
<ion-button shape="round" [disabled]="submission.inProgress()" (click)="save()">
{{ t('PERSONS.SAVE') }}
</ion-button>
<ion-button shape="round" fill="outline" (click)="back()">{{ t('PERSONS.BACK') }}</ion-button>
</div>
} @else {
<div class="ion-text-center ion-padding"><ion-spinner /></div>
}
</ion-content>
|
- linhas 9–13: os campos de identidade (veja [person-fields.ts]);
- linhas 16–34: o nome de usuário e a senha, com textos de ajuda diferentes para criação e modificação (deixar o campo de senha em branco não a altera). A senha nunca é preenchida previamente: o servidor nunca a retorna. [params]: parâmetros da mensagem de erro da senha ([{{min}}]...).
11.13.12. src/app/pages/register.ts
| // =========================================================================
// src/app/pages/register.ts - "Criar uma conta de paciente" (/register)
// -------------------------------------------------------------------------
// Só se chega aqui depois de copiar o captcha da tela de login
// (botão "Criar uma conta de paciente"): o servidor então emitiu um
// passe (um cookie), que o guard da rota verificou (veja
// app.routes.ts). Mesmos campos do formulário do ADMIN, mas o login
// e a senha são obrigatórios, com confirmação.
// =========================================================================
import { Component, computed, inject, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';
import { Data, RdvMedecinsApi } from '../api/rdvmedecins-api';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { FormSubmission } from '../components/form-submission';
import { Messages } from '../state/messages';
import { Translations } from '../i18n/translations';
// tamanho mínimo de uma senha escolhida por um paciente: mesmo valor
// do servidor (que também devolve {min} com o erro PASSWORD_TOO_SHORT)
const minPassword = '6';
@Component({
selector: 'app-register',
imports: [IonContent, IonButton, InputField, PersonFields],
templateUrl: './register.html',
})
export class RegisterPage {
private readonly api = inject(RdvMedecinsApi);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
readonly t = inject(Translations).t;
readonly submission = new FormSubmission(this.messages);
readonly form = signal<Data>({
title: 'Mr',
firstName: '',
lastName: '',
login: '',
password: '',
confirmation: '',
});
// os parâmetros da mensagem de ajuda E dos erros de senha
readonly passwordParams = computed(() => ({ min: minPassword, ...this.submission.params() }));
text(field: string): string {
return String(this.form()[field] ?? '');
}
update(field: string, value: string): void {
this.form.update((f) => ({ ...f, [field]: value }));
this.submission.clearError(field);
}
backToLogin(): void {
void this.router.navigateByUrl('/login');
}
async create(): Promise<void> {
let login = '';
const succeeded = await this.submission.submit(async () => {
login = await this.api.register(this.form());
});
if (succeeded) {
// volta para a tela de login, com o login preenchido
this.messages.flash({ key: 'REGISTRATION.DONE', params: { login } });
void this.router.navigate(['/login'], { queryParams: { login } });
} else if (this.messages.error()?.key === 'ERRORS.CAPTCHA_BEFORE_ACCOUNT') {
// passe expirado (15 minutos): volta para o captcha
this.messages.flash({ success: false, key: 'ERRORS.CAPTCHA_BEFORE_ACCOUNT' });
this.backToLogin();
}
}
}
|
Criação de uma conta de paciente, acessível com o passe emitido pela tela de login (veja [registrationGuard] em [app.routes.ts]).
- linha 23: o comprimento mínimo da senha; para a mensagem de ajuda: o mesmo valor do servidor (que também o retorna com o erro [PASSWORD_TOO_SHORT]);
- Linha 47: os parâmetros da mensagem de ajuda e do erro de senha ([{{min}}]): os parâmetros do servidor, se houver, têm precedência;
- Linhas 62–76: criação. Em caso de sucesso: volta à tela de login, com o nome de usuário preenchido previamente ([/login?login=...]: [queryParams] constrói o parâmetro), junto com uma mensagem flash. Em caso de falha porque o passe expirou (15 minutos): volta ao CAPTCHA. Quaisquer outros erros permanecem exibidos abaixo dos campos.
11.13.13. src/app/pages/register.html
| <!-- ======================================================================
register.html - "Create a patient account"
====================================================================== -->
<ion-content class="ion-padding">
<h1>{{ t('REGISTRATION.TITLE') }}</h1>
<p class="intro">{{ t('REGISTRATION.INTRO') }}</p>
<app-person-fields
[values]="form()"
[errors]="submission.errors()"
(fieldChange)="update($event.field, $event.value)"
/>
<h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
<app-input-field
label="PERSONS.LOGIN_LABEL"
autocomplete="username"
[maxLength]="30"
[value]="text('login')"
(valueChange)="update('login', $event)"
[error]="submission.errors()['login']"
help="REGISTRATION.LOGIN_HELP"
/>
<app-input-field
label="PERSONS.PASSWORD_LABEL"
autocomplete="new-password"
[secret]="true"
[maxLength]="72"
[value]="text('password')"
(valueChange)="update('password', $event)"
[error]="submission.errors()['password']"
[params]="passwordParams()"
help="REGISTRATION.PASSWORD_HELP"
/>
<app-input-field
label="ACCOUNT.CONFIRMATION_LABEL"
autocomplete="new-password"
[secret]="true"
[maxLength]="72"
[value]="text('confirmation')"
(valueChange)="update('confirmation', $event)"
[error]="submission.errors()['confirmation']"
/>
<div class="buttons">
<ion-button shape="round" [disabled]="submission.inProgress()" (click)="create()">
{{ t('REGISTRATION.SUBMIT') }}
</ion-button>
<ion-button shape="round" fill="outline" (click)="backToLogin()">
{{ t('REGISTRATION.BACK_TO_LOGIN') }}
</ion-button>
</div>
</ion-content>
|
- linhas 16–44: uma conta NOVA: [autocomplete="new-password"] leva o gerenciador de senhas a sugerir uma senha forte e a salvá-la.
11.13.14. src/app/pages/patient-area.ts
| // =========================================================================
// src/app/pages/patient-area.ts - "Minha área" (/my-area, papel USER)
// -------------------------------------------------------------------------
// A tela inicial do paciente, logo após o login:
// - duas opções: [Gerenciar minha conta] e [Ver uma agenda];
// - sua consulta futura, se houver, com o meio de cancelá-la.
// =========================================================================
import { Component, inject, resource } from '@angular/core';
import { Router } from '@angular/router';
import {
IonButton, IonCard, IonCardContent, IonCardHeader, IonCardTitle, IonContent, IonIcon, IonItem, IonLabel,
IonSpinner,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { calendar, personCircle } from 'ionicons/icons';
import { RdvMedecinsApi } from '../api/rdvmedecins-api';
import { label, Appointment } from '../api/types';
import { Confirmation } from '../components/confirmation';
import { Cache, reloadAfterInvalidation } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { timeRange, longDay } from '../formatting';
import { Translations } from '../i18n/translations';
import { scheduleUrl } from './schedule';
@Component({
selector: 'app-patient-area',
imports: [
IonContent, IonCard, IonCardHeader, IonCardTitle, IonCardContent, IonItem, IonLabel, IonIcon, IonButton,
IonSpinner,
],
templateUrl: './patient-area.html',
styleUrl: './patient-area.scss',
})
export class PatientAreaPage {
private readonly api = inject(RdvMedecinsApi);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
private readonly confirmation = inject(Confirmation);
private readonly translations = inject(Translations);
readonly t = this.translations.t;
readonly label = label;
readonly timeRange = timeRange;
readonly area = resource({
loader: () => this.cache.read('my-area', () => this.api.myArea()),
});
constructor() {
addIcons({ calendar, personCircle });
reloadAfterInvalidation(this.area);
reportErrors(this.area);
}
// "Monday, October 5, 2026, 8:00 - 8:20"
when(a: Appointment): string {
return `${longDay(a.day, this.translations.language())}, ${timeRange(a.slot)}`;
}
goTo(url: string): void {
void this.router.navigateByUrl(url);
}
// a agenda do médico nesse dia: o paciente vê seu nome nela
seeInSchedule(a: Appointment): void {
this.goTo(scheduleUrl(a.doctor.id, a.day));
}
async cancel(appointmentId: number): Promise<void> {
if (!(await this.confirmation.ask('SCHEDULE.CANCEL_CONFIRM'))) return;
try {
await this.api.cancelAppointment(appointmentId);
this.messages.showSuccess('SCHEDULE.CANCELLED');
} catch (e) {
this.messages.showApiError(e);
}
// a área E as agendas mudaram (a área é lida novamente: reloadAfterInvalidation)
this.cache.invalidate('my-area');
this.cache.invalidate('schedule');
}
}
|
A área do paciente: duas opções e sua próxima consulta.
- linhas 46–48: o painel do paciente, vindo do cache;
- linhas 57–59: "terça-feira, 13 de outubro de 2026, 8h00–8h20";
- linhas 66–68: a agenda do médico nesse dia: o paciente vê seu nome ali;
- linhas 70–81: cancelamento da consulta do paciente: a área E as agendas mudaram.
11.13.15. src/app/pages/patient-area.html
| <!-- ======================================================================
patient-area.html - "My area"
====================================================================== -->
<ion-content class="ion-padding">
@if (area.hasValue()) {
@let e = area.value();
<h1>{{ t('AREA.HELLO', { name: label(e.patient) }) }}</h1>
<!-- dois "cards" de opção, tocados para abrir uma tela;
detail: o chevron > à direita -->
<ion-card>
<ion-item [button]="true" [detail]="true" lines="none" (click)="goTo('/my-account')">
<ion-icon slot="start" name="person-circle" color="primary" />
<ion-label class="ion-text-wrap">
<h2>{{ t('AREA.MANAGE_ACCOUNT') }}</h2>
<p>{{ t('AREA.MANAGE_ACCOUNT_HELP') }}</p>
</ion-label>
</ion-item>
</ion-card>
<ion-card>
<ion-item [button]="true" [detail]="true" lines="none" (click)="goTo('/schedule')">
<ion-icon slot="start" name="calendar" color="primary" />
<ion-label class="ion-text-wrap">
<h2>{{ t('AREA.VIEW_SCHEDULE') }}</h2>
<p>{{ t('AREA.VIEW_SCHEDULE_HELP') }}</p>
</ion-label>
</ion-item>
</ion-card>
<ion-card>
<ion-card-header>
<ion-card-title>{{ t('AREA.MY_APPOINTMENT') }}</ion-card-title>
</ion-card-header>
<ion-card-content>
<!-- normalmente apenas uma (regra "uma consulta futura por vez"),
mas a tela pode exibir várias -->
@for (a of e.appointments; track a.id) {
<div class="when">{{ when(a) }}</div>
<div>{{ label(a.doctor) }}</div>
<div class="buttons">
<ion-button fill="clear" (click)="seeInSchedule(a)">{{ t('AREA.SEE_IN_SCHEDULE') }}</ion-button>
<ion-button fill="outline" shape="round" color="danger" (click)="cancel(a.id)">
{{ t('AREA.CANCEL_APPOINTMENT') }}
</ion-button>
</div>
} @empty {
<p class="none">{{ t('AREA.NO_APPOINTMENT') }}</p>
}
</ion-card-content>
</ion-card>
} @else if (area.isLoading()) {
<div class="ion-text-center ion-padding"><ion-spinner /></div>
}
</ion-content>
|
- linha 7: [@let]: uma variável de template, para evitar repetir [area.value()];
- linhas 12–29: duas opções: cartões em que você toca para abrir uma tela. [ion-item] e [button] respondem ao toque; [detail] adiciona a seta > à direita;
- linhas 38–49: a consulta e dois botões: ver a agenda do médico nesse dia, cancelar; ou, se não houver consulta ([@empty]), uma mensagem.
11.13.16. src/app/pages/patient-area.scss
| // =========================================================================
// patient-area.scss - os estilos de "Minha área"
// =========================================================================
ion-card {
margin: 0 0 12px;
}
// os ícones das opções, maiores
ion-item ion-icon[slot='start'] {
font-size: 32px;
}
ion-item h2 {
font-weight: 500;
}
ion-card-title {
font-size: 19px;
}
.when {
font-weight: 600;
color: var(--ion-text-color, #000);
}
.none {
color: var(--ion-color-medium);
}
|
Cartões sem margens laterais (a tela já tem as suas), ícones maiores para as opções e a data da consulta em negrito.
11.13.17. src/app/pages/my-account.ts
| // =========================================================================
// src/app/pages/my-account.ts - "Gerenciar minha conta" (/my-account, papel USER)
// -------------------------------------------------------------------------
// Dois formulários independentes:
// 1. a atualização (identidade, login, nova senha opcional);
// 2. a exclusão da conta - que também cancela suas consultas.
// Ambos exigem a senha ATUAL (verificada pelo servidor).
// Dois formulários, portanto dois FormSubmission (dois conjuntos de erros). Como
// no formulário de pessoas, a atualização só é exibida depois que
// a conta foi lida, e começa com seus valores.
// =========================================================================
import { Component, inject, linkedSignal, resource, signal } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonCard, IonCardContent, IonContent, IonSpinner } from '@ionic/angular';
import { Data, RdvMedecinsApi } from '../api/rdvmedecins-api';
import { InputField } from '../components/input-field';
import { PersonFields } from '../components/person-fields';
import { Confirmation } from '../components/confirmation';
import { FormSubmission } from '../components/form-submission';
import { Cache } from '../state/cache';
import { Messages, reportErrors } from '../state/messages';
import { Session } from '../state/session';
import { Translations } from '../i18n/translations';
@Component({
selector: 'app-my-account',
imports: [IonContent, IonCard, IonCardContent, IonButton, IonSpinner, InputField, PersonFields],
templateUrl: './my-account.html',
styleUrl: './my-account.scss',
})
export class MyAccountPage {
private readonly api = inject(RdvMedecinsApi);
private readonly session = inject(Session);
private readonly cache = inject(Cache);
private readonly messages = inject(Messages);
private readonly router = inject(Router);
private readonly confirmation = inject(Confirmation);
readonly t = inject(Translations).t;
// ------------------------------------------------ 1. a atualização
// lida novamente a cada visita, sem cache: sua versão deve estar atualizada
readonly account = resource({ loader: () => this.api.myAccount() });
readonly editing = new FormSubmission(this.messages);
readonly form = linkedSignal<Data>(() => {
if (!this.account.hasValue()) return {};
const a = this.account.value();
return {
title: a.title,
firstName: a.firstName,
lastName: a.lastName,
login: a.login,
password: '',
confirmation: '',
currentPassword: '',
version: a.version,
};
});
// ------------------------------------------------ 2. a exclusão
readonly deletion = new FormSubmission(this.messages);
readonly deletePassword = signal('');
constructor() {
reportErrors(this.account);
}
text(field: string): string {
return String(this.form()[field] ?? '');
}
update(field: string, value: string): void {
this.form.update((f) => ({ ...f, [field]: value }));
this.editing.clearError(field);
}
back(): void {
void this.router.navigateByUrl('/my-area');
}
async save(): Promise<void> {
const succeeded = await this.editing.submit(async () => {
// o servidor emitiu um NOVO token (nome, login): a barra superior deve acompanhar
this.session.update(await this.api.editMyAccount(this.form()));
this.messages.flash({ key: 'MY_ACCOUNT.UPDATED' });
});
if (succeeded) {
this.cache.invalidate('my-area');
this.back();
} else {
// nunca uma senha deixada no campo após um envio rejeitado;
// o valor é alterado SEM passar por update(), para não apagar
// o erro que o servidor acabou de anexar a ele
this.form.update((f) => ({ ...f, currentPassword: '' }));
}
}
changeDeletePassword(value: string): void {
this.deletePassword.set(value);
this.deletion.clearError('currentPassword');
}
async deleteAccount(): Promise<void> {
if (!(await this.confirmation.ask('MY_ACCOUNT.DELETE_CONFIRM'))) return;
const succeeded = await this.deletion.submit(() => this.api.deleteMyAccount(this.deletePassword()));
if (succeeded) {
// primeiro a mensagem: ela será exibida na tela de login, para onde
// os guards nos levam assim que a sessão fica vazia
this.messages.flash({ key: 'MY_ACCOUNT.DELETED' });
this.session.forget(true); // o servidor excluiu o cookie do token
}
}
}
|
"Gerenciar minha conta": dois formulários separados, cada um com seu próprio [FormSubmission].
- Linha 43: a conta, relida a cada visita, sem cache (sua versão deve estar atualizada);
- Linhas 45–58: os inputs começam com os valores da conta, depois que a conta foi lida;
- linhas 81–96: edição. O servidor retorna o usuário com as informações atualizadas (e um novo token em seu cookie): a sessão é atualizada, e o nome exibido no menu é atualizado de acordo. Após uma tentativa malsucedida, a senha atual é limpa do campo, sem apagar a mensagem de erro que o servidor acabou de associar a ela;
- linhas 103–112: exclusão da conta, após confirmação. Primeiro, a mensagem (uma mensagem flash); depois a sessão é limpa e os guards exibem a tela de login, junto com a mensagem.
11.13.18. src/app/pages/my-account.html
| <!-- ======================================================================
my-account.html - "Manage my account"
====================================================================== -->
<ion-content class="ion-padding">
<!-- 1. a atualização -->
<ion-card>
<ion-card-content>
<h1>{{ t('MY_ACCOUNT.TITLE') }}</h1>
@if (account.hasValue()) {
<app-person-fields
[values]="form()"
[errors]="editing.errors()"
(fieldChange)="update($event.field, $event.value)"
/>
<h3>{{ t('PERSONS.ACCOUNT_SECTION') }}</h3>
<app-input-field
label="PERSONS.LOGIN_LABEL"
autocomplete="username"
[maxLength]="30"
[value]="text('login')"
(valueChange)="update('login', $event)"
[error]="editing.errors()['login']"
/>
<app-input-field
label="MY_ACCOUNT.NEW_PASSWORD_LABEL"
autocomplete="new-password"
[secret]="true"
[maxLength]="72"
[value]="text('password')"
(valueChange)="update('password', $event)"
[error]="editing.errors()['password']"
[params]="editing.params()"
help="PERSONS.PASSWORD_HELP_EDIT"
/>
<app-input-field
label="ACCOUNT.CONFIRMATION_LABEL"
autocomplete="new-password"
[secret]="true"
[maxLength]="72"
[value]="text('confirmation')"
(valueChange)="update('confirmation', $event)"
[error]="editing.errors()['confirmation']"
/>
<app-input-field
label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
autocomplete="current-password"
[secret]="true"
[maxLength]="72"
[value]="text('currentPassword')"
(valueChange)="update('currentPassword', $event)"
[error]="editing.errors()['currentPassword']"
help="MY_ACCOUNT.CURRENT_PASSWORD_HELP"
/>
<div class="buttons">
<ion-button shape="round" [disabled]="editing.inProgress()" (click)="save()">
{{ t('PERSONS.SAVE') }}
</ion-button>
<ion-button shape="round" fill="outline" (click)="back()">{{ t('MY_ACCOUNT.BACK') }}</ion-button>
</div>
} @else {
<div class="ion-text-center ion-padding"><ion-spinner /></div>
}
</ion-card-content>
</ion-card>
<!-- 2. a exclusão: um formulário com um único campo -->
<ion-card class="danger">
<ion-card-content>
<h1>{{ t('MY_ACCOUNT.DELETE_TITLE') }}</h1>
<p class="help">{{ t('MY_ACCOUNT.DELETE_HELP') }}</p>
<app-input-field
label="MY_ACCOUNT.CURRENT_PASSWORD_LABEL"
autocomplete="current-password"
[secret]="true"
[maxLength]="72"
[value]="deletePassword()"
(valueChange)="changeDeletePassword($event)"
[error]="deletion.errors()['currentPassword']"
/>
<ion-button shape="round" color="danger" [disabled]="deletion.inProgress()" (click)="deleteAccount()">
{{ t('MY_ACCOUNT.DELETE_SUBMIT') }}
</ion-button>
</ion-card-content>
</ion-card>
</ion-content>
|
- linhas 7–65: edição, em um cartão; o formulário só aparece depois que a conta foi lida;
- linhas 68–85: exclusão, em um cartão com borda vermelha: um formulário de campo único.
11.13.19. src/app/pages/my-account.scss
| // =========================================================================
// my-account.scss - os estilos de "Gerenciar minha conta"
// =========================================================================
ion-card {
margin: 0 0 12px;
}
ion-card-content {
color: var(--ion-text-color, #000);
// os títulos, como nos demais lugares (o Ionic lhes dá outras margens em um card)
h1 {
font-size: 26px;
margin: 8px 0 16px;
}
h3 {
font-size: 15px;
font-weight: 500;
margin: 16px 0 12px;
}
}
// o card de exclusão: uma moldura vermelha, um título vermelho
ion-card.danger {
border: 1px solid #e57373;
h1 {
color: #d32f2f;
}
}
|
Os títulos nos cartões (o [Ionic] lhes dá tamanhos e margens diferentes em um [ion-card-content]) e a borda vermelha da exclusão.
11.13.20. src/app/pages/error-page.ts
| // =========================================================================
// src/app/pages/error-page.ts - a tela de erro: 404 (endereço desconhecido)
// ou 403 (papel insuficiente, veja app.routes.ts)
// -------------------------------------------------------------------------
// O código (403 ou 404) é dado pela propriedade data da rota.
// =========================================================================
import { Component, inject, input } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';
import { Translations } from '../i18n/translations';
@Component({
selector: 'app-error-page',
imports: [IonContent, IonButton],
templateUrl: './error-page.html',
styles: `
.error {
color: #d32f2f;
}
`,
})
export class ErrorPage {
private readonly router = inject(Router);
readonly t = inject(Translations).t;
readonly code = input(404);
// "/": o guard redireciona para a página inicial do papel (ou o login)
home(): void {
void this.router.navigateByUrl('/');
}
}
|
| <!-- ======================================================================
error-page.html - a tela de erro (403, 404)
====================================================================== -->
<ion-content class="ion-padding">
<h1 class="error">{{ t('ERROR_PAGE.TITLE') }} {{ code() }}</h1>
<p>{{ t(code() === 403 ? 'ERRORS.FORBIDDEN' : 'ERRORS.NOT_FOUND') }}</p>
<ion-button shape="round" (click)="home()">{{ t('ERROR_PAGE.BACK') }}</ion-button>
</ion-content>
|
A página de erro: 404 (endereço desconhecido) ou 403 (permissões insuficientes). O código é a propriedade [data] da rota, atribuída ao input [code] (linha 26 de [error-page.ts]). "Voltar à página inicial" leva a [/], que o guard redireciona para a página inicial do papel.
11.14. Flutter e Ionic: uma comparação
Os dois clientes fazem exatamente a mesma coisa, com a mesma arquitetura, arquivo por arquivo. Algumas diferenças merecem destaque:
- o cookie de token: o cliente [Flutter] precisava gerenciá-lo por conta própria no telefone (um cliente HTTP que lê [Set-Cookie] e escreve [Cookie]); o cliente [Ionic] se apoia no navegador web e no código nativo do [Android] ([CapacitorHttp]) no telefone;
- Estado e atualizações: os [ChangeNotifier] do [Flutter] notificam seus ouvintes ([notifyListeners()]), e os widgets se reconstroem; os signals do [Angular] sabem QUEM os lê e atualizam apenas o que depende deles. Os signals calculados ([computed]), os signals vinculados ([linkedSignal]) e os resources ([resource]) substituem boa parte de [initState], [didUpdateWidget] e [FutureBuilder];
- Endereço: em ambos os casos, todo o estado da tela está contido no endereço; o roteador do [Angular] o passa diretamente aos inputs do componente ([withComponentInputBinding]);
- componentes prontos: o [Ionic] fornece o menu permanente em tela grande ([ion-split-pane]), as janelas ([ion-modal], [ion-popover], [AlertController]) e o calendário ([ion-datetime]); o [Flutter] fornece os seus próprios ([NavigationRail], [showDatePicker]...), mas a janela de agendamento vinculada ao endereço foi desenhada à mão lá;
- A web: o cliente [Ionic] É uma aplicação web (baseada em HTML, algumas centenas de quilobytes); o cliente [Flutter], compilado para a web, desenha cada pixel em um canvas e antes baixa seu mecanismo de renderização (alguns megabytes). Em contraste, no telefone, o aplicativo [Flutter] é compilado em código de máquina, enquanto o aplicativo [Ionic] é executado dentro do [WebView], o mecanismo do navegador.