5. Roteamento
Uma aplicação tem várias telas. Na web, cada tela tem um endereço (/ex17/doctors/2): ela pode ser referenciada, aberta por um link, recarregada ou protegida por guards. O [Angular] gerencia esses endereços por meio de seu roteador (o pacote [@angular/router]), que usamos desde o primeiro exemplo: a página inicial da aplicação de exemplo associa o endereço /ex01 à página do Exemplo 01, /ex02 à página do Exemplo 02, e assim por diante. O [Ionic] não substitui esse roteador: ele se apoia nele e acrescenta as funcionalidades esperadas de um aplicativo móvel. Seu componente [<ion-router-outlet>]organiza as páginas em uma pilha: uma nova página é empilhada sobre a anterior (com a animação do Android), o botão Voltar do celular a remove da pilha, e a página anterior — que permanece na memória — reaparece exatamente como foi deixada. Ele combina o [Navigator] do [Flutter] e o pacote [go_router].
5.1. Exemplo 17: o roteador
O Exemplo 17 tem seis páginas: uma página inicial, uma lista de médicos, o perfil de um médico, uma página de busca, uma página “About” carregada sob demanda e uma página para endereços desconhecidos. As cinco primeiras são agrupadas em um “shell”, com uma barra de abas na parte inferior da tela (quatro abas: a página de detalhes de um médico pertence à aba Doctors).
5.1.1. Os dados
| // =========================================================================
// src/app/ex17-router/data.ts - os dados do exemplo 17
// -------------------------------------------------------------------------
// Dados "fixos no código", para não depender de um servidor neste exemplo.
// =========================================================================
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
}
export const doctors: Doctor[] = [
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];
|
Dados “fixos no código”, para não depender de um servidor neste exemplo: um array de objetos descritos pela [Doctor] interface.
5.1.2. As rotas
| // =========================================================================
// src/app/ex17-router/routes.ts - as ROTAS do exemplo 17
// -------------------------------------------------------------------------
// Uma aplicação tem várias telas ("páginas"). O ROTEADOR do Angular
// associa um ENDEREÇO (um path, como na web: /ex17/doctors/2) a
// uma página. O Ionic se apoia nele: seu <ion-router-outlet> o transforma em uma
// PILHA de páginas (empilhamos, desempilhamos, o botão Voltar do Android desempilha).
// Estas rotas são as FILHAS da rota /ex17 de app.routes.ts
// (loadChildren): seus paths são relativos a /ex17.
// 'doctors/:id' :id é um parâmetro (/ex17/doctors/2 -> id = "2");
// children rotas exibidas DENTRO do "shell" (a barra
// superior, a barra de abas na parte inferior);
// redirectTo um redirecionamento: o endereço antigo leva ao novo;
// '**' o "curinga": qualquer endereço que nenhuma rota reconhece;
// title o título do documento (aba do navegador);
// loadComponent carregamento ADIADO: o código da página só é
// baixado na primeira visita.
// =========================================================================
import { ResolveFn, Routes } from '@angular/router';
import { Shell } from './shell';
import { doctors } from './data';
import { Home } from './pages/home.page';
import { DoctorDetail } from './pages/doctor-detail.page';
import { DoctorList } from './pages/doctor-list.page';
import { NotFoundPage } from './pages/not-found.page';
import { Search } from './pages/search.page';
// o título da página de um médico, calculado a partir do parâmetro :id do endereço
const doctorTitle: ResolveFn<string> = (route) => {
const doctor = doctors.find((m) => m.id === Number(route.paramMap.get('id')));
return doctor ? `${doctor.firstName} ${doctor.lastName}` : 'Unknown doctor';
};
export const routes: Routes = [
{
// o shell (Shell) contém a barra de abas; suas rotas
// filhas são exibidas DENTRO do shell, acima da barra
path: '',
component: Shell,
children: [
// /ex17 sozinho: vamos para a aba inicial
{ path: '', redirectTo: 'home', pathMatch: 'full' },
{ path: 'home', title: 'Home', component: Home },
{ path: 'doctors', title: 'Doctors', component: DoctorList },
// uma página com um PARÂMETRO: /ex17/doctors/2; ela começa com
// 'doctors': pertence à aba Doctors, na qual ela
// empilha uma página acima da lista
{ path: 'doctors/:id', title: doctorTitle, component: DoctorDetail },
// /ex17/search?q=pediatrician: o parâmetro q é um parâmetro de QUERY
{ path: 'search', title: 'Search', component: Search },
// carregamento adiado: import() é um import DINÂMICO
// (uma Promise); o código da página é colocado em um arquivo separado
{
path: 'about',
title: 'About',
loadComponent: () => import('./pages/about.page').then((m) => m.About),
},
// um redirecionamento: a rota não tem página, ela envia para outro endereço
{ path: 'physicians', redirectTo: 'doctors' },
],
},
// qualquer outro endereço sob /ex17: a página de não encontrado, FORA do shell
{ path: '**', title: 'Page not found', component: NotFoundPage },
];
|
Uma rota associa um caminho a uma página. As rotas do Exemplo 17 ficam em sua pasta, e a rota /ex17 da aplicação as carrega por meio de [loadChildren] (abordado adiante): são rotas filhas de /ex17, e seus caminhos são relativos a /ex17 ([home] refere-se ao endereço /ex17/home).
- Linhas 30–33: uma função do tipo [ResolveFn<string>], que calcula o título da página de um médico com base no parâmetro [:id] da URL ([route.paramMap.get('id')]). A propriedade [title] de uma rota é o título do documento (a aba do navegador, na web): uma string ou uma função como essa. É o equivalente do widget [Title] do [Flutter];
- Linhas 36–41: o shell do exemplo. A rota não tem caminho próprio ([path: '']); ela exibe o componente [Shell] (a barra superior e a barra de abas), e suas rotas filhas ([children]) são exibidas DENTRO do shell. É o equivalente de [ShellRoute] do [go_router];
- linha 43: o endereço /ex17 sozinho é redirecionado para /ex17/home. [pathMatch: 'full']: a rota só se aplica se o restante do endereço estiver vazio (caso contrário, o caminho vazio — que é o início de todo endereço — sempre se aplicaria);
- linhas 44–45: uma rota padrão: seu caminho, seu título e seu componente de página;
- linha 49: uma rota com um parâmetro: [doctors/:id], em que [:id] é um parâmetro ([/ex17/doctors/2]: [id] equivale a ["2"], que é sempre uma string). Com o [go_router], essa rota era aninhada na da lista; aqui, ela fica ao lado. Seu caminho começa com [doctors]: para o [Ionic], ela pertence à aba Doctors, e sua página é empilhada acima da lista, na pilha dessa aba;
- linha 51: a busca. Seus parâmetros de consulta (depois de [?]: [/ex17/search?q=pediatrician]) não aparecem no caminho da rota: qualquer rota pode aceitá-los;
- Linhas 54–58: carregamento tardio. [loadComponent] é uma função que retorna uma [Promise]: [import('./pages/about.page')] é uma importação dinâmica do [JavaScript], que carrega o arquivo quando é executada, e [then] extrai dele o componente. A compilação ([ng build]) coloca então o código da página em um arquivo [JavaScript] separado, que é baixado na primeira visita à página. É o equivalente da importação do [Dart] com [deferred as];
- linha 60: um redirecionamento: a rota não tem página; ela redireciona para outro endereço. [redirectTo] também pode ser uma função que calcula o endereço;
- linha 64: a rota curinga [**] corresponde a qualquer endereço que nenhuma rota anterior tenha correspondido (o roteador tenta as rotas em ordem). Ela é colocada fora do shell: a página “page not found” tem sua própria barra de cabeçalho. É o equivalente de [errorBuilder] do [go_router].
5.1.3. Inicialização
O roteador é configurado de uma vez por todas, quando a aplicação inicia, no arquivo [main.ts]:
| // o roteador: a lista de rotas (app.routes.ts);
// withComponentInputBinding: os parâmetros de uma rota são entregues aos
// inputs (input) do componente da página (veja o exemplo 17)
provideRouter(routes, withComponentInputBinding()),
|
- linha 32: [provideRouter] recebe a lista de rotas da aplicação; a opção [withComponentInputBinding()] fornece os parâmetros de uma rota (os do caminho, como [:id], e os da requisição, como [?q=]) aos inputs ([input()]) de mesmo nome no componente da página. É isso que substitui, aqui, [state.pathParameters['id']] do [go_router].
E a rota /ex17 da aplicação (arquivo [app.routes.ts]) carrega as rotas do exemplo:
| // os exemplos 17 e 18 têm suas próprias rotas, "filhas" de /ex17 e /ex18
{ path: 'ex17', loadChildren: () => import('./ex17-router/routes').then((m) => m.routes) },
{ path: 'ex18', loadChildren: () => import('./ex18-guards/routes').then((m) => m.routes) },
|
- linha 31: [loadChildren]: como [loadComponent], uma importação dinâmica; o arquivo do exemplo [routes.ts], e tudo o que ele importa, só é baixado na primeira vez que se visita uma URL começando por /ex17.
5.1.4. O shell da aplicação
| // =========================================================================
// src/app/ex17-router/shell.ts - o "shell" do exemplo 17
// -------------------------------------------------------------------------
// A barra superior, a barra de abas na parte inferior e, entre as duas, a página
// da rota atual. É o componente <ion-tabs> do Ionic:
// - <ion-tab-bar slot="bottom">: a barra de abas, na parte inferior;
// - <ion-tab-button tab="doctors">: uma aba; tocá-la leva ao
// endereço /ex17/doctors. A aba ativa é aquela cujo nome é o
// primeiro segmento do endereço (depois de /ex17): /ex17/doctors/2 -> Doctors;
// - cada aba tem sua PRÓPRIA pilha de páginas: podemos entrar no
// detalhe de um médico, mudar para a aba Search, voltar à
// aba Doctors... e encontrar o detalhe novamente.
// =========================================================================
import { Component, computed, inject } from '@angular/core';
import { Router } from '@angular/router';
import {
IonBackButton, IonButtons, IonHeader, IonIcon, IonLabel, IonTabBar, IonTabButton, IonTabs, IonTitle, IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { home, informationCircle, people, search } from 'ionicons/icons';
import { DeferredLoading } from './pages/deferred-loading';
// as abas: o nome da aba (= o path, depois de /ex17), o rótulo, o ícone
const tabs = [
{ tab: 'home', label: 'Home', icon: 'home' },
{ tab: 'doctors', label: 'Doctors', icon: 'people' },
{ tab: 'search', label: 'Search', icon: 'search' },
{ tab: 'about', label: 'About', icon: 'information-circle' },
];
@Component({
selector: 'app-ex17-shell',
imports: [
IonTabs, IonTabBar, IonTabButton, IonIcon, IonLabel, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle,
DeferredLoading,
],
templateUrl: './shell.html',
styles: `
.address {
background: var(--ion-color-light);
color: var(--ion-color-light-contrast);
padding: 8px;
font-family: monospace;
font-size: 12px;
}
`,
})
export class Shell {
readonly tabs = tabs;
private readonly router = inject(Router);
// o endereço atual. lastSuccessfulNavigation é um SIGNAL do roteador:
// a última navegação bem-sucedida; finalUrl: seu endereço, depois dos
// redirecionamentos. decodeURIComponent: %20 volta a ser um espaço
readonly address = computed(() => {
const navigation = this.router.lastSuccessfulNavigation();
return navigation?.finalUrl ? decodeURIComponent(this.router.serializeUrl(navigation.finalUrl)) : '';
});
constructor() {
// os ícones usados pelo template
addIcons({ home, people, search, informationCircle });
}
}
|
| <!-- ======================================================================
shell.html - o shell do exemplo 17: <ion-tabs>
====================================================================== -->
<ion-tabs>
<!-- slot="top": colocado ACIMA das páginas das abas -->
<ion-header slot="top">
<ion-toolbar color="primary">
<ion-buttons slot="start">
<!-- este botão Voltar sai do exemplo: ele desempilha o shell -->
<ion-back-button defaultHref="/" />
</ion-buttons>
<ion-title>Example 17 - the router</ion-title>
</ion-toolbar>
<div class="address">current address: {{ address() }}</div>
<!-- uma barra de progresso, enquanto uma página adiada está carregando -->
<app-deferred-loading />
</ion-header>
<!-- aqui, o próprio <ion-tabs> coloca um <ion-router-outlet>: a página da
rota filha atual -->
<!-- a barra de abas, na parte inferior: típica de uma aplicação mobile -->
<ion-tab-bar slot="bottom">
@for (tab of tabs; track tab.tab) {
<ion-tab-button [tab]="tab.tab">
<ion-icon [name]="tab.icon" />
<ion-label>{{ tab.label }}</ion-label>
</ion-tab-button>
}
</ion-tab-bar>
</ion-tabs>
|
O shell é o componente [<ion-tabs>] do [Ionic]: uma barra de abas e, acima dela, a página da aba selecionada.
- linhas 25–30 (shell.ts): as abas: um nome (que também é o caminho depois de /ex17), um rótulo e um ícone;
- linhas 56–59 (shell.ts): o endereço atual, um signal calculado ([computed]). O roteador expõe signals: [lastSuccessfulNavigation()], a última navegação bem-sucedida, e [currentNavigation()], a navegação em andamento (abordada adiante). [finalUrl] é o endereço de destino, após os redirecionamentos; [serializeUrl] o converte em uma string; [decodeURIComponent] decodifica os caracteres codificados ([%20] volta a ser um espaço). Como o signal é relido a cada navegação, o endereço exibido acompanha;
- linha 63 (shell.ts): os ícones usados pelo template;
- linhas 7–18 (shell.html): a barra superior. [<ion-tabs>] coloca os elementos marcados com [slot="top"] acima das páginas das abas, e os demais abaixo. O botão Voltar dessa barra fecha todo o shell: ele leva você de volta ao menu de exemplos;
- linha 15 (shell.html): o endereço atual;
- linha 17 (shell.html): uma barra de progresso, exibida durante a navegação (veja adiante);
- linhas 20–21 (shell.html): o próprio [<ion-tabs>] coloca, entre as duas barras, um [<ion-router-outlet>]: a página da rota filha atual. Nós não o escrevemos;
- linhas 24–31 (shell.html): a barra de abas inferior ([<ion-tab-bar slot="bottom">]), típica de um aplicativo móvel, é o equivalente de [NavigationBar] do [Flutter]. Cada [<ion-tab-button [tab]="...">] é uma aba; tocar nela leva ao endereço /ex17/<tab name>.
Duas diferenças em relação ao [go_router]:
- a aba ativa não é calculada pelo código: o [<ion-tabs>] a deduz da URL (a aba cujo nome é o primeiro segmento da URL, depois de /ex17: [/ex17/doctors/2] refere-se à aba [doctors]);
- Cada aba tem sua própria pilha de páginas. Se você vir os detalhes de um médico, mudar para a aba Search e depois voltar à aba Doctors, verá novamente os detalhes do médico, e o botão Voltar o leva de volta à lista. Esse é o comportamento padrão dos aplicativos móveis (como os de [Android] e [iOS]).
5.1.5. As páginas
As páginas das abas têm apenas um [<ion-content>]: sua barra superior é a do shell.
| // =========================================================================
// src/app/ex17-router/pages/home.page.ts - a aba inicial
// -------------------------------------------------------------------------
// routerLink: um LINK para um endereço; um toque leva até lá, como um link
// <a href> na web, mas sem recarregar a aplicação.
// =========================================================================
import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';
@Component({
selector: 'app-ex17-home',
imports: [RouterLink, IonContent, IonButton],
templateUrl: './home.page.html',
})
export class Home {}
|
| <!-- ======================================================================
home.page.html - a aba inicial do exemplo 17
====================================================================== -->
<!-- uma página de aba só tem seu conteúdo: a barra superior é a do shell -->
<ion-content class="ion-padding">
<p>
Welcome. Touch the tabs: the screen changes, and so does its address. On the web, the address
is displayed in the browser's bar, the Back and Forward buttons work, as does
reloading (F5) any page.
</p>
<!-- links para endereços específicos -->
<ion-button fill="outline" routerLink="/ex17/physicians">/ex17/physicians (redirection)</ion-button>
<ion-button fill="outline" routerLink="/ex17/unknown-page">Broken link</ion-button>
</ion-content>
|
- linhas 13–14 (HTML): dois links. A diretiva [routerLink] do [Angular] (importada na linha 9 do arquivo .ts) transforma qualquer elemento em um link: tocar nele leva ao endereço especificado, exatamente como um link [<a href>] na web, mas sem recarregar a aplicação. O primeiro leva ao redirecionamento /ex17/physicians; o segundo, a um endereço que não existe.
| // =========================================================================
// src/app/ex17-router/pages/doctor-list.page.ts - links com um parâmetro
// -------------------------------------------------------------------------
// [routerLink]="['/ex17/doctors', m.id]": o endereço é construído a partir de
// um array de segmentos: /ex17/doctors/2. A página do médico é
// EMPILHADA acima da lista: o botão Voltar retorna a ela.
// =========================================================================
import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { IonContent, IonItem, IonLabel, IonList } from '@ionic/angular';
import { doctors } from '../data';
@Component({
selector: 'app-ex17-doctor-list',
imports: [RouterLink, IonContent, IonList, IonItem, IonLabel],
templateUrl: './doctor-list.page.html',
})
export class DoctorList {
readonly doctors = doctors;
}
|
| <!-- ======================================================================
doctor-list.page.html - a aba Doctors do exemplo 17
====================================================================== -->
<ion-content>
<ion-list>
@for (m of doctors; track m.id) {
<!-- button: o item reage ao toque; detail: a seta > à direita -->
<ion-item button detail [routerLink]="['/ex17/doctors', m.id]">
<ion-label>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</ion-label>
</ion-item>
}
</ion-list>
</ion-content>
|
- Linha 9 (HTML): um item de lista clicável ([button]), com uma seta para a direita ([detail]). Sua URL é construída a partir de um array de segmentos: [[routerLink]="['/ex17/doctors', m.id]"] resulta em /ex17/doctors/2. A página do médico é EMPILHADA sobre a lista (uma navegação “para a frente”): o botão Voltar retorna a essa página.
| // =========================================================================
// src/app/ex17-router/pages/doctor-detail.page.ts - uma página com um parâmetro
// -------------------------------------------------------------------------
// O roteador entrega o parâmetro :id do endereço ao INPUT id da página
// (input), uma STRING ("2"): é o withComponentInputBinding() (main.ts).
// Se passamos de /ex17/doctors/1 para /ex17/doctors/2, o Angular mantém a
// mesma página e apenas muda o valor do input: o médico
// exibido, calculado (computed) a partir dele, acompanha.
// Navegação pelo CÓDIGO: NavController, o serviço de navegação do Ionic.
// =========================================================================
import { Component, computed, inject, input } from '@angular/core';
import { IonButton, IonContent, IonRouterOutlet, IonText, NavController } from '@ionic/angular';
import { doctors } from '../data';
@Component({
selector: 'app-ex17-doctor-detail',
imports: [IonContent, IonButton, IonText],
templateUrl: './doctor-detail.page.html',
})
export class DoctorDetail {
// o parâmetro :id do endereço
readonly id = input.required<string>();
// Number("abc") é NaN: nenhum médico será encontrado (undefined)
readonly doctor = computed(() => doctors.find((m) => m.id === Number(this.id())));
// o número do próximo médico: 1 -> 2 -> 3 -> 1
readonly next = computed(() => ((this.doctor()?.id ?? 0) % doctors.length) + 1);
private readonly navCtrl = inject(NavController);
// a pilha de páginas da aba (o <ion-router-outlet> que exibe esta página)
private readonly outlet = inject(IonRouterOutlet);
back(): void {
// canGoBack: há uma página por baixo? (não, se chegamos
// diretamente a este endereço, na web)
if (this.outlet.canGoBack()) {
this.outlet.pop();
} else {
this.navCtrl.navigateBack('/ex17/doctors');
}
}
nextDoctor(): void {
// replaceUrl: o endereço SUBSTITUI o endereço atual no histórico
// (sem push: o botão Voltar leva de volta à lista)
this.navCtrl.navigateForward(['/ex17/doctors', this.next()], { replaceUrl: true });
}
}
|
| <!-- ======================================================================
doctor-detail.page.html - a página de um médico (exemplo 17)
====================================================================== -->
<ion-content class="ion-padding">
<!-- @if (...; as m): o valor do teste, chamado m, no bloco -->
@if (doctor(); as m) {
<h2>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</h2>
<p>Specialty: {{ m.specialty }}</p>
<ion-button fill="outline" (click)="back()">Back</ion-button>
<ion-button (click)="nextDoctor()">Next doctor</ion-button>
} @else {
<ion-text color="danger">Doctor no. {{ id() }} does not exist.</ion-text>
}
</ion-content>
|
- linha 23 (.ts): o input [id], que recebe o parâmetro [:id] do endereço ([withComponentInputBinding]). [input.required<string>()]: um input obrigatório, do tipo string;
- Linha 26 (.ts): o médico, um signal calculado a partir do input. [Number("abc")] é igual a [NaN], que não é igual a nenhum número: um [id] incorreto resulta em [undefined] (era [int.tryParse] com o [Dart]). Se você navegar de /ex17/doctors/1 para /ex17/doctors/2, o [Angular] mantém a mesma página e apenas altera o valor do input: o médico exibido acompanha;
- linha 28 (.ts): o número do próximo médico (1, 2, 3 e depois 1);
- linha 30 (.ts): [NavController], o serviço de navegação do [Ionic]: navegação via CÓDIGO;
- linha 32 (.ts): [IonRouterOutlet]: a pilha de páginas que exibe esta página (a da aba “Doctors”);
- linhas 34–42 (.ts): o botão Voltar da página. Se houver uma página abaixo dela ([canGoBack()]), ela é removida da pilha ([pop()]); caso contrário (na web, o usuário pode ter chegado diretamente a este endereço), o usuário é levado à lista com uma animação de “volta” ([navigateBack]);
- linhas 44–48 (.ts): o próximo médico: uma navegação “para a frente” ([navigateForward]), mas com [replaceUrl: true]: o novo endereço SUBSTITUI o endereço atual no histórico. Sem pilha: o botão Voltar retorna à lista, e não ao médico anterior (o que era [context.pushReplacement] com o [go_router]);
- Linhas 7–14 (HTML): [@if (doctor(); as m)]: se o médico existe, ele é chamado de [m] dentro do bloco; caso contrário ([@else]), aparece uma mensagem.
Com o [Ionic], há três formas de navegar:
- por um link: [routerLink];
- pelo roteador do [Angular]: [router.navigate([...])] ou [router.navigateByUrl('...')];
- pelo [NavController] do [Ionic]: [navigateForward] (empilhar uma página era [context.push]), [navigateBack] (voltar, desempilhando as páginas do topo), [navigateRoot] (começar com uma nova pilha — era [context.go]), [back()] (como o botão Voltar). Esses métodos chamam o roteador do [Angular], especificando a DIREÇÃO da navegação, da qual dependem a animação e o gerenciamento da pilha.
| // =========================================================================
// src/app/ex17-router/pages/search.page.ts - uma página guiada pelo endereço
// -------------------------------------------------------------------------
// /ex17/search?q=pediatrician: a página é inteiramente descrita por seu
// endereço. Na web, podemos guardá-la nos favoritos, recarregá-la, voltar
// atrás. Pesquisar significa IR ao endereço /ex17/search?q=...:
// a página exibe o que o endereço diz, e nada mais.
// O parâmetro de QUERY q (depois do ?) também é entregue ao input
// de mesmo nome (withComponentInputBinding); ele é undefined se ausente.
// =========================================================================
import { Component, computed, inject, input } from '@angular/core';
import { Router } from '@angular/router';
import { IonContent, IonItem, IonLabel, IonList, IonSearchbar } from '@ionic/angular';
import { doctors } from '../data';
@Component({
selector: 'app-ex17-search',
imports: [IonContent, IonSearchbar, IonList, IonItem, IonLabel],
templateUrl: './search.page.html',
})
export class Search {
// o parâmetro ?q=... do endereço
readonly q = input<string>();
// os resultados: recalculados quando o endereço (portanto q) muda
readonly results = computed(() => {
const text = (this.q() ?? '').toLowerCase();
return doctors.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text));
});
private readonly router = inject(Router);
search(input: string): void {
// queryParams: o roteador constrói o endereço, codificando o que for
// necessário (espaço -> %20)
this.router.navigate(['/ex17/search'], { queryParams: { q: input.trim() } });
}
}
|
| <!-- ======================================================================
search.page.html - a aba Search do exemplo 17
====================================================================== -->
<ion-content class="ion-padding">
<!-- um campo NÃO controlado: [value] lhe dá o valor do endereço (e
o dá de novo se o endereço mudar: botão Voltar do navegador);
#field: uma referência ao componente, para ler seu valor;
enterkeyhint="search": a tecla Enter do teclado vira uma lupa -->
<ion-searchbar
#field
placeholder="name or specialty"
enterkeyhint="search"
[value]="q() ?? ''"
(keyup.enter)="search(field.value ?? '')"
/>
<ion-list>
@for (m of results(); track m.id) {
<ion-item>
<ion-label>{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</ion-label>
</ion-item>
} @empty {
<ion-item>
<ion-label color="medium">No result.</ion-label>
</ion-item>
}
</ion-list>
</ion-content>
|
- Linha 24 (.ts): o input [q] recebe o parâmetro de requisição [?q=...]. Ele pode estar ausente: nesse caso, o input é [undefined], o que resulta no tipo [input<string>()] (uma string ou [undefined]) e nos valores [?? ''];
- linhas 27–30 (.ts): os resultados, recalculados quando o endereço (isto é, [q]) muda;
- linhas 34–38 (.ts): a busca — ela VAI para o endereço /ex17/search?q=<input>. [router.navigate] recebe o caminho, e [queryParams] recebe os parâmetros de requisição; ele constrói a URL codificando as partes necessárias (um espaço se torna [%20]). A página é totalmente descrita por seu endereço: na web, você pode salvá-la nos favoritos, recarregá-la ou voltar;
- Linhas 10–16 (HTML): uma barra de busca do [Ionic] ([<ion-searchbar>], com sua lupa e seu botão de limpar). É um campo NÃO controlado: [[value]] define seu valor a partir do endereço e o redefine se o endereço mudar (pelo botão Voltar do navegador), exatamente como a chave [ValueKey(q)] do [Flutter]. [#field] é uma variável de referência de template: ela se refere ao componente cujo valor ([field.value]) é lido quando a tecla Enter ([(keyup.enter)]) é pressionada. [enterkeyhint="search"]: a tecla Enter do teclado do celular se torna uma lupa;
- linhas 18–26 (html): os resultados; [@empty]: o conteúdo exibido quando a lista está vazia.
| // =========================================================================
// src/app/ex17-router/pages/about.page.ts - uma página carregada sob demanda
// -------------------------------------------------------------------------
// Veja loadComponent em routes.ts: o código desta página é colocado, pela
// compilação (ng build), em um arquivo JavaScript separado.
// =========================================================================
import { Component } from '@angular/core';
import { IonContent } from '@ionic/angular';
@Component({
selector: 'app-ex17-about',
imports: [IonContent],
templateUrl: './about.page.html',
})
export class About {}
|
| <!-- ======================================================================
about.page.html - a aba About do exemplo 17
====================================================================== -->
<ion-content class="ion-padding">
<p>
On the web, the code of this page was downloaded on the first visit (Network tab of the
development tools: a chunk-XXXXXXXX.js file). On a phone, this file is
already in the application: it is read on the spot, without download.
</p>
</ion-content>
|
A página carregada sob demanda (veja [loadComponent] em [routes.ts]) não tem nada de especial: é a rota que determina o carregamento tardio. O resultado de [ng build] exibe seu arquivo separado (“Lazy chunk files ... about-page”). Na aplicação de exemplo, aliás, todas as páginas são carregadas dessa forma (veja [app.routes.ts]): na inicialização, apenas o menu é baixado.
| // =========================================================================
// src/app/ex17-router/pages/deferred-loading.ts
// -------------------------------------------------------------------------
// Uma barra de progresso, exibida enquanto uma navegação está EM ANDAMENTO:
// durante esse tempo, o roteador baixa o código de uma página adiada
// (loadComponent), ou espera a resposta de um guard (exemplo 18).
// currentNavigation é um SIGNAL do roteador: a navegação em andamento, ou
// null quando não há nenhuma.
// =========================================================================
import { Component, inject } from '@angular/core';
import { Router } from '@angular/router';
import { IonProgressBar } from '@ionic/angular';
@Component({
selector: 'app-deferred-loading',
imports: [IonProgressBar],
templateUrl: './deferred-loading.html',
})
export class DeferredLoading {
readonly router = inject(Router);
}
|
| <!-- ======================================================================
deferred-loading.html - uma barra de progresso "indeterminada"
====================================================================== -->
@if (router.currentNavigation()) {
<ion-progress-bar type="indeterminate" />
}
|
Com o [Flutter], o widget [DeferredLoading] exibia um indicador de carregamento enquanto esperava o código da página. Com o [Angular], o próprio roteador espera o código antes de exibir a página: a página anterior permanece na tela nesse intervalo. O componente [DeferredLoading] exibe, portanto, uma barra de progresso enquanto houver navegação em andamento:
- linha 5 (html): [router.currentNavigation()] é um signal do roteador: a navegação em andamento ou [null]. Enquanto uma página tardia é baixada (ou enquanto se espera por um guard, exemplo 18), a barra de progresso ([<ion-progress-bar type="indeterminate">], uma barra animada sem fim) é exibida; ao fim da navegação, o signal volta a [null], e ela desaparece. O shell a coloca abaixo de sua barra superior (linha 17 de shell.html).
| // =========================================================================
// src/app/ex17-router/pages/not-found.page.ts - os endereços desconhecidos
// -------------------------------------------------------------------------
// A página da rota curinga '**' (routes.ts): ela fica FORA do
// shell, portanto tem sua própria barra superior.
// =========================================================================
import { Component, computed, inject } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, IonHeader, IonText, IonTitle, IonToolbar, NavController } from '@ionic/angular';
@Component({
selector: 'app-ex17-not-found-page',
imports: [IonHeader, IonToolbar, IonTitle, IonContent, IonText, IonButton],
templateUrl: './not-found.page.html',
})
export class NotFoundPage {
private readonly router = inject(Router);
private readonly navCtrl = inject(NavController);
// o endereço solicitado (veja shell.ts)
readonly address = computed(() => {
const navigation = this.router.lastSuccessfulNavigation();
return navigation?.finalUrl ? decodeURIComponent(this.router.serializeUrl(navigation.finalUrl)) : '';
});
backHome(): void {
// navigateBack: uma navegação "para trás" (a animação vai da esquerda
// para a direita); a página de não encontrado é desempilhada
this.navCtrl.navigateBack('/ex17/home');
}
}
|
| <!-- ======================================================================
not-found.page.html - a página de endereços desconhecidos (exemplo 17)
====================================================================== -->
<ion-header>
<ion-toolbar color="primary">
<ion-title>Page not found</ion-title>
</ion-toolbar>
</ion-header>
<ion-content class="ion-padding">
<p><ion-text color="danger">No page at the address {{ address() }}.</ion-text></p>
<ion-button (click)="backHome()">Back to home</ion-button>
</ion-content>
|
A página de endereços desconhecidos fica fora do shell: ela tem sua própria barra superior (linhas 5–9 do HTML). Ela exibe o endereço solicitado (linhas 22–25 do arquivo .ts, como no shell), e seu botão leva o usuário de volta à página inicial por uma navegação de “volta” (linha 30 do arquivo .ts): a página “page not found” é desempilhada, e o shell, que permanecia na memória por baixo, reaparece.
5.1.6. Execução
A página inicial; o perfil de um médico (empilhado sobre a lista: a barra de abas continua lá, e o botão Voltar do celular retorna à lista); os resultados da busca depois de digitar “general practitioner” e pressionar Enter; um endereço desconhecido (o link quebrado da página inicial):
Em um navegador ([ng serve]), o endereço também aparece na barra de endereços, os botões Voltar e Avançar funcionam, e é possível digitar um endereço manualmente: /ex17/doctors/3, /ex17/search?q=pediatrician, /ex17/physicians....
Em comparação com o [go_router], o roteador do [Angular] é mais declarativo: as rotas são uma simples lista de objetos, os parâmetros são passados aos campos de input da página, e o carregamento tardio é simplesmente uma propriedade da rota. O [Ionic] acrescenta recursos específicos de dispositivos móveis: a pilha de páginas ([<ion-router-outlet>]), abas com pilhas separadas ([<ion-tabs>]), direção de navegação e animações de navegação ([NavController]). Encontraremos exatamente os mesmos conceitos no cliente [Angular] do [RdvMedecins] (as rotas, [routerLink], [router.navigate]): apenas os componentes do [Ionic] são específicos de dispositivos móveis.
5.2. Exemplo 18: restrições de navegação
Certas páginas só devem ser abertas por um usuário logado ou por um usuário com um papel específico. O roteador do [Angular] as protege com guards: funções que ele chama antes de prosseguir para essas páginas.
5.2.1. A sessão
| // =========================================================================
// src/app/ex18-guards/session.ts - uma sessão SIMULADA (sem servidor)
// -------------------------------------------------------------------------
// O usuário conectado deve ser conhecido pelas PÁGINAS (a barra superior,
// a agenda) e pelos GUARDS do roteador (funções, que não são
// componentes). Nós o guardamos em um SERVIÇO, um único objeto que todos
// obtêm com inject(Session) (veja o exemplo 14):
// - um signal privado, o estado;
// - uma visão somente leitura desse signal;
// - métodos para modificá-lo.
// Quem lê o signal (os templates) é notificado quando ele muda.
// (O exemplo 23 fará a mesma coisa com um servidor real.)
// =========================================================================
import { Injectable, signal } from '@angular/core';
export type Role = 'ADMIN' | 'DOCTOR' | 'USER';
export interface User {
login: string;
role: Role;
}
// três contas "fixas no código" (senha = login)
const accounts: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };
// providedIn: 'root': UMA única instância, para toda a aplicação
@Injectable({ providedIn: 'root' })
export class Session {
// o estado: null, ninguém está conectado
private readonly _user = signal<User | null>(null);
// asReadonly: podemos ler o signal, não modificá-lo
readonly user = this._user.asReadonly();
logIn(login: string, password: string): boolean {
const role = accounts[login];
if (role === undefined || password !== login) {
return false;
}
this._user.set({ login, role });
return true;
}
logOut(): void {
this._user.set(null);
}
}
|
O usuário logado precisa ser reconhecido pelas páginas (a barra superior, a agenda) e pelos guards do roteador — elementos que não são componentes. Ele é armazenado em um serviço (veja o Exemplo 14), um objeto único que todos obtêm por meio de [inject(Session)]:
- linhas 17–22: os papéis (um tipo “union” formado por três strings) e o usuário;
- linha 25: três contas “fixas no código” (senha = login): um objeto que associa um login a um papel ([Record<string, Role>]);
- linha 28: [providedIn: 'root']: uma única instância do serviço para toda a aplicação;
- linhas 31–33: o estado, um signal privado ([null]: ninguém está logado), e sua visão somente leitura ([asReadonly()]): os demais podem lê-lo, mas somente os métodos do serviço podem modificá-lo;
- linhas 35–42: a conexão, simulada. Ela modifica o signal: tudo o que o lê (templates, signals calculados) acompanha. É o [notifyListeners()] do [ChangeNotifier] do [Flutter], sem precisar escrevê-lo. (O Exemplo 23 fará o mesmo com um servidor de verdade.)
5.2.2. Guards e rotas protegidas
| // =========================================================================
// src/app/ex18-guards/routes.ts - rotas PROTEGIDAS por guards
// -------------------------------------------------------------------------
// canActivate: a lista dos GUARDS de uma rota, funções (do tipo
// CanActivateFn) que o roteador chama ANTES de ir até ela. Um guard recebe
// a rota solicitada e o estado da navegação (state.url: o endereço
// solicitado), e retorna:
// - true: a navegação continua;
// - false: ela é cancelada;
// - uma UrlTree (um endereço construído pelo roteador): a navegação
// é substituída por uma navegação para esse endereço.
// Um guard pode usar inject(): ele é chamado em um "contexto
// de injeção".
//
// É o equivalente, no lado do cliente, dos guards do NestJS (JwtAuthGuard,
// RolesGuard) - com uma diferença FUNDAMENTAL: um guard de cliente é
// apenas uma conveniência. A aplicação está nas mãos do usuário, que
// pode modificá-la à vontade. A proteção real dos dados continua sendo
// a do SERVIDOR (veja o capítulo sobre a caixa-preta).
// =========================================================================
import { inject } from '@angular/core';
import { CanActivateFn, Router, Routes } from '@angular/router';
import { Shell } from './shell';
import { Home } from './pages/home.page';
import { Schedule } from './pages/schedule.page';
import { Login } from './pages/login.page';
import { Role, Session } from './session';
// o guard "login obrigatório": sem login -> para a página de login,
// lembrando para onde queríamos ir (parâmetro returnUrl)
export const loginRequired: CanActivateFn = (route, state) => {
if (inject(Session).user() === null) {
return inject(Router).createUrlTree(['/ex18/login'], { queryParams: { returnUrl: state.url } });
}
return true;
};
// o guard "papel obrigatório": uma função que CONSTRÓI um guard
export function roleRequired(...roles: Role[]): CanActivateFn {
return (route, state) => {
const u = inject(Session).user();
if (u === null || !roles.includes(u.role)) {
// logado, mas sem o papel adequado: volta para a página inicial, com um motivo
return inject(Router).createUrlTree(['/ex18'], { queryParams: { denied: state.url } });
}
return true;
};
}
export const routes: Routes = [
{
path: '',
component: Shell,
children: [
{ path: '', pathMatch: 'full', component: Home },
{ path: 'login', component: Login },
{ path: 'schedule', canActivate: [loginRequired], component: Schedule },
{
path: 'administration',
// os guards, em ordem: vence o primeiro que não retornar true
canActivate: [loginRequired, roleRequired('ADMIN')],
// o código da página só é carregado depois que os guards são superados
loadComponent: () => import('./pages/administration.page').then((m) => m.Administration),
},
// qualquer outro endereço (nenhuma rota corresponde): volta para a página inicial
{ path: '**', redirectTo: '' },
],
},
];
|
Um guard de ativação é uma função do tipo [CanActivateFn], colocada na lista [canActivate] de uma rota. O roteador a chama antes de prosseguir para essa rota; ela recebe a rota solicitada e o estado da navegação ([state.url]: o endereço solicitado) e retorna:
- [true]: a navegação continua;
- [false]: a navegação é cancelada;
- uma [UrlTree], um endereço gerado pelo roteador ([router.createUrlTree]): a navegação é substituída pela navegação para esse endereço.
Um guard também pode retornar uma [Promise] ou um [Observable] com um desses valores (para consultar um servidor, por exemplo). O código:
- linhas 32–37: o guard “login obrigatório”: não está logado? Redireciona para a página de login, mantendo o destino pretendido (parâmetro de requisição [returnUrl]). O guard usa [inject()]: o roteador o chama em um “contexto de injeção”;
- linhas 40–49: o guard “papel obrigatório” é CONSTRUÍDO por uma função, que recebe os papéis permitidos ([...roles]: quantos parâmetros se quiser, agrupados em um array) e retorna o guard. Logado, mas sem o papel correto: redirecionado para a página inicial, com um motivo (parâmetro [denied]);
- linhas 52–55: o shell e suas rotas filhas, como no Exemplo 17;
- linha 58: a página da agenda exige que o usuário esteja logado;
- linhas 59–65: a administração exige que o usuário esteja logado E tenha o papel ADMIN. Os guards da lista são chamados em ordem; o primeiro que não retorna [true] vence (neste caso, era a cadeia de [??] para [go_router]). O código da página é carregado ([loadComponent]) somente depois que os guards são superados;
- linha 67: qualquer outro endereço sob /ex18 redireciona para a página inicial.
Este é o equivalente, no cliente, das proteções do servidor [NestJS] ([JwtAuthGuard], [RolesGuard]), com uma fundamental diferença: um guard no cliente é apenas uma conveniência (para evitar exibir uma tela desnecessária). A aplicação está nas mãos do usuário, que pode modificá-la à vontade; a verdadeira proteção dos dados continua no servidor, que reverifica tudo a cada requisição (veja o capítulo sobre a caixa-preta).
Uma diferença em relação ao [go_router]: sua opção [refreshListenable] reavaliava os guards da página atual a cada mudança de sessão (você era redirecionado para a página de login se saísse da agenda). O roteador do [Angular] só chama os guards durante a navegação. É por isso que o logout (descrito mais adiante) é seguido de uma navegação para a página inicial.
5.2.3. O shell e as páginas
| // =========================================================================
// src/app/ex18-guards/shell.ts - os links e o usuário logado
// -------------------------------------------------------------------------
// A página do exemplo 18: a barra superior (o usuário logado), uma
// barra de links e, abaixo, a página da rota filha atual, colocada
// por <router-outlet>. O template LÊ o signal da sessão: ele, portanto,
// acompanha o usuário logado.
// =========================================================================
import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import {
IonBackButton, IonButton, IonButtons, IonChip, IonContent, IonHeader, IonIcon, IonTitle, IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { logOutOutline } from 'ionicons/icons';
import { DeferredLoading } from '../ex17-router/pages/deferred-loading';
import { Session } from './session';
@Component({
selector: 'app-ex18-shell',
imports: [
RouterOutlet, RouterLink, RouterLinkActive, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle,
IonButton, IonChip, IonIcon, IonContent, DeferredLoading,
],
templateUrl: './shell.html',
styles: `
.links ion-button { text-transform: none; }
.links .active { font-weight: bold; }
`,
})
export class Shell {
readonly session = inject(Session);
private readonly router = inject(Router);
constructor() {
addIcons({ logOutOutline });
}
logOut(): void {
this.session.logOut();
this.router.navigateByUrl('/ex18');
}
}
|
| <!-- ======================================================================
shell.html - o shell do exemplo 18
====================================================================== -->
<ion-header>
<ion-toolbar color="primary">
<ion-buttons slot="start">
<ion-back-button defaultHref="/" />
</ion-buttons>
<ion-title>Example 18 - guards</ion-title>
<ion-buttons slot="end">
<!-- @if (...; as u): o usuário logado, chamado de u dentro do bloco -->
@if (session.user(); as u) {
<ion-chip outline color="light">{{ u.login }} {{ u.role }}</ion-chip>
<ion-button aria-label="logout" (click)="logOut()">
<ion-icon slot="icon-only" name="log-out-outline" />
</ion-button>
} @else {
<ion-button routerLink="/ex18/login">login</ion-button>
}
</ion-buttons>
</ion-toolbar>
<!-- os links; routerLinkActive: a classe CSS "active" é aplicada ao
link que designa a página exibida; exact: o endereço inteiro deve
corresponder (caso contrário /ex18 estaria "active" em todas as páginas) -->
<ion-toolbar class="links">
<ion-button fill="clear" size="small" routerLink="/ex18" routerLinkActive="active"
[routerLinkActiveOptions]="{ exact: true }">Home</ion-button>
<ion-button fill="clear" size="small" routerLink="/ex18/schedule" routerLinkActive="active">
Schedule (logged in)</ion-button>
<ion-button fill="clear" size="small" routerLink="/ex18/administration" routerLinkActive="active">
Administration (ADMIN)</ion-button>
</ion-toolbar>
<app-deferred-loading />
</ion-header>
<ion-content class="ion-padding">
<!-- a página da rota filha atual -->
<router-outlet />
</ion-content>
|
- linha 17 (.ts): o shell reutiliza a barra de progresso do Exemplo 17;
- linhas 40–43 (.ts): logout e, em seguida, a página inicial;
- Linhas 11–21 (HTML): a barra superior lê o token da sessão; ela acompanha o usuário logado (era o [ListenableBuilder] com [Flutter]). Quando há um usuário logado, um [<ion-chip>] (um “chip”) exibe o login e o papel do usuário ao lado de um botão de logout; caso contrário, aparece um link para a página de login;
- linhas 26–33 (HTML): uma segunda barra contendo os links. A diretiva [routerLinkActive="active"] aplica a classe CSS [active] (em negrito, linha 29 do arquivo .ts) ao link que aponta para a página exibida. Para a página inicial, [[routerLinkActiveOptions]="{ exact: true }"] exige que a URL completa corresponda: caso contrário, como /ex18 é o início de todas as URLs do exemplo, esse link estaria sempre “ativo”;
- linha 39 (html): [<router-outlet>], e o do [Angular]: a página da rota filha atual. Essas páginas são apenas trechos do conteúdo do shell, sem a barra superior nem a animação: o simples [<router-outlet>] do [Angular] é suficiente dentro do [<ion-content>] do shell. O [<ion-router-outlet>] do [Ionic] é reservado para páginas completas, que são empilhadas.
| // =========================================================================
// src/app/ex18-guards/pages/login.page.ts - a página de login
// -------------------------------------------------------------------------
// Depois do login, enviamos o usuário de volta à página que ele queria
// abrir (parâmetro ?returnUrl=... colocado pelo guard), ou à página inicial.
// =========================================================================
import { Component, inject, input, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { IonButton, IonCard, IonCardContent, IonInput, IonText } from '@ionic/angular';
import { Session } from '../session';
@Component({
selector: 'app-ex18-login',
imports: [FormsModule, IonCard, IonCardContent, IonInput, IonButton, IonText],
templateUrl: './login.page.html',
})
export class Login {
// o endereço solicitado, colocado pelo guard loginRequired
readonly returnUrl = input<string>();
// os campos do formulário e o erro: signals
readonly login = signal('');
readonly password = signal('');
readonly error = signal(false);
private readonly session = inject(Session);
private readonly router = inject(Router);
submit(): void {
if (!this.session.logIn(this.login().trim(), this.password())) {
this.error.set(true);
return;
}
// só aceitamos um caminho INTERNO: começa com /, mas não com //
// (//site.com/... designa OUTRO site) - nenhum redirecionamento para outro site
const r = this.returnUrl();
const internal = r !== undefined && r.startsWith('/') && !r.startsWith('//');
this.router.navigateByUrl(internal ? r : '/ex18');
}
}
|
| <!-- ======================================================================
login.page.html - o formulário de login (exemplo 18)
====================================================================== -->
@if (returnUrl()) {
<ion-card color="warning">
<ion-card-content>Log in to open {{ returnUrl() }}.</ion-card-content>
</ion-card>
}
<!-- [(ngModel)]="login": o campo e o signal login permanecem iguais -->
<ion-input label="login" labelPlacement="floating" fill="outline" class="ion-margin-bottom" [(ngModel)]="login" />
<ion-input label="password" labelPlacement="floating" fill="outline" type="password"
[(ngModel)]="password" (keyup.enter)="submit()" />
<ion-button class="ion-margin-top" (click)="submit()">Log in</ion-button>
@if (error()) {
<p><ion-text color="danger">Incorrect login or password.</ion-text></p>
}
|
- linha 21 (.ts): o endereço solicitado, informado pelo guard no parâmetro [returnUrl];
- linhas 24–26 (.ts): os campos do formulário e o erro: signals;
- linhas 31–41 (.ts): a conexão. Se falhar, um erro é retornado; caso contrário, o usuário é redirecionado para a página que queria abrir ou para a página inicial. Só um caminho interno é aceito: ele começa com [/], mas não com [//] ([//site.com/...] refere-se a OUTRO site). Na web, um endereço de conexão gerado por um terceiro ([/ex18/login?returnUrl=//pirate-site.com]) nunca levará, portanto, a outro lugar. [router.navigateByUrl] aceita um endereço completo, incluindo seus parâmetros de consulta;
- linhas 5–9 (HTML): o motivo da conexão;
- linhas 11–13 (html): [[(ngModel)]="login"] vincula o campo ao signal [login] nos dois sentidos (veja o exemplo 05); [(keyup.enter)] envia o formulário ao pressionar a tecla Enter.
As outras páginas são muito simples:
| // =========================================================================
// src/app/ex18-guards/pages/home.page.ts - a página pública
// -------------------------------------------------------------------------
// ?denied=...: colocado no endereço pelo guard roleRequired quando o papel
// não é adequado; o roteador o entrega ao input denied.
// =========================================================================
import { Component, input } from '@angular/core';
import { IonCard, IonCardContent } from '@ionic/angular';
@Component({
selector: 'app-ex18-home',
imports: [IonCard, IonCardContent],
templateUrl: './home.page.html',
})
export class Home {
readonly denied = input<string>();
}
|
| <!-- ======================================================================
home.page.html - a página pública do exemplo 18
====================================================================== -->
@if (denied()) {
<ion-card color="danger">
<ion-card-content>Your role does not allow opening {{ denied() }}.</ion-card-content>
</ion-card>
}
<p>Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).</p>
|
| // =========================================================================
// src/app/ex18-guards/pages/schedule.page.ts - uma página reservada a usuários logados
// =========================================================================
import { Component, inject } from '@angular/core';
import { Session } from '../session';
@Component({
selector: 'app-ex18-schedule',
templateUrl: './schedule.page.html',
})
export class Schedule {
readonly session = inject(Session);
}
|
| <!-- ======================================================================
schedule.page.html - a página de agenda (exemplo 18)
====================================================================== -->
<p>The schedule of <strong>{{ session.user()?.login }}</strong>: this page requires being logged in.</p>
|
| // =========================================================================
// src/app/ex18-guards/pages/administration.page.ts - reservada ao papel ADMIN
// -------------------------------------------------------------------------
// Carregada sob demanda (loadComponent, em routes.ts): seu código só é
// baixado na primeira visita, e somente se os guards a permitirem.
// =========================================================================
import { Component } from '@angular/core';
@Component({
selector: 'app-ex18-administration',
templateUrl: './administration.page.html',
})
export class Administration {}
|
| <!-- ======================================================================
administration.page.html - a página de administração (exemplo 18)
====================================================================== -->
<p>
Administration: page reserved for the ADMIN role, loaded on demand (on the web, its code is only
downloaded on the first visit, and only if the guards allowed it).
</p>
|
A página inicial recebe o parâmetro [denied] definido pelo guard [roleRequired] (linha 17 do arquivo .ts); a página da agenda lê a sessão.
5.2.4. Execução
Sem estar logado, solicitamos a interface de administração: o guard nos redireciona para a página de login (à esquerda). Fazemos login com a conta [martin] (papel USER): o login nos leva de volta à interface de administração, onde o segundo guard nega o acesso (no meio). Fazemos logout, solicitamos novamente a página de administração e fazemos login com a conta [admin]: a página é aberta (à direita):
Os guards do [Angular] também existem em outras formas: [canMatch] (a rota nem sequer é reconhecida se o guard recusar: seu código não é baixado), [canDeactivate] (sair da página: “Descartar as alterações?”), [canActivateChild] (para todas as rotas filhas de uma rota). O cliente [Angular] do [RdvMedecins] os utiliza da mesma forma: um guard no cliente apenas orienta o usuário; quem decide é o servidor.