6. Clientes HTTP do serviço de cálculo de imposto

6.1. Introdução
Nesta seção, escreveremos um cliente [node.js] para o serviço de cálculo de imposto configurado no capítulo “Instalação de um servidor NestJS”. A arquitetura cliente/servidor será a seguinte:

Examinaremos duas versões do cliente:
- A versão 1 do cliente terá a seguinte estrutura em camadas: [main, dao]:

- A versão 2 do cliente terá a estrutura [main, business, dao]. A camada [business] do servidor será transferida para o cliente:

6.2. Cliente HTTP 1

Como mencionado, o cliente HTTP 1 implementa a seguinte arquitetura cliente/servidor:

Implementaremos:
- a camada [dao] como uma classe;
- a camada [main] como um script que usa essa classe;
6.2.1. A camada [dao]
A camada [dao] será implementada pela seguinte classe, [Dao1.ts]:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | |
- Aqui aplicamos o que aprendemos no capítulo sobre as funções HTTP do TypeScript;
- Linhas 14–20: o construtor da classe. Essa classe terá três propriedades:
- [axios]: o objeto [axios] usado para fazer as requisições HTTP. Ele é passado pelo código chamador;
- [sessionCookieName]: Dependendo do servidor, o cookie de sessão pode ter nomes diferentes. Aqui, é [PHPSESSID];
- [sessionCookie]: o cookie de sessão enviado pelo servidor e armazenado pelo cliente;
- linhas 62–85: a função assíncrona [calculateTax] faz a requisição [post /main.php?action=calculate-tax] enviando os parâmetros [married, children, salary]. Ela retorna como objeto JavaScript a string jSON transmitida pelo servidor;
- linhas 88–102: A função assíncrona [listSimulations] faz a requisição [get /main.php?action=list-simulations]. Ela retorna como objeto JavaScript a string jSON enviada pelo servidor;
- linhas 105–120: A função assíncrona [deleteSimulation] faz a requisição [get /main.php?action=delete-simulation&number=index]. Ela retorna como objeto JavaScript a string jSON enviada pelo servidor;
- linha 132: a notação [this.axios] é usada porque aqui o objeto [axios] passado ao construtor foi armazenado na propriedade [this.axios] (linha 9);
- linha 172: a classe [Dao1] é exportada para poder ser usada;
6.2.2. O script [main1]
Este script encadeia uma série de chamadas ao servidor por meio da classe Dao1: inicialização da sessão, autenticação, três cálculos de imposto (em paralelo), uma listagem das simulações e a exclusão de uma delas:
Comentários
- linha 3: a biblioteca [axios] é importada;
- linha 5: importa a classe [Dao];
- linha 9: a função [main], que se comunica com o servidor, é assíncrona;
- Linhas 11–12: Configuração padrão das requisições HTTP que serão enviadas ao servidor:
- linha 9: [timeout] com um tempo limite de 2 segundos;
- linha 10: todas as requisições de URL são prefixadas com a URL base do servidor de cálculo de imposto (http://localhost:3000);
- linha 14 : a camada [Dao] é construída. Agora ela pode ser usada;
- linhas 48–50: a função [log] serve para exibir de forma formatada a string jSON de um objeto JavaScript: na vertical, com indentação de dois espaços (3º parâmetro);
- linhas 17–20: inicialização da sessão jSON;
- Linhas 21–24: autenticação;
- linhas 25–32: Três cálculos de imposto são solicitados em paralelo. Graças ao [await Promise.all], a execução fica bloqueada até que os três resultados tenham sido obtidos;
- linhas 33–36: listagem das simulações;
- linhas 37–40: exclusão de uma simulação;
- linhas 41–44: tratamento de eventuais exceções;
Os resultados da execução são os seguintes:
Resultado da execução:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | |
6.3. Cliente HTTP 2

A arquitetura do cliente HTTP 2 é a seguinte:

A camada [business] foi movida do servidor para o cliente JavaScript. Aqui, a camada [main] não precisará passar pela camada [business] para chegar à camada [dao]. Usaremos essas duas camadas como centros de especialização:
- a camada [main] passa pela camada [dao] sempre que precisa de dados que estão no servidor;
- a camada [main] pede à camada [business] que realize os cálculos de imposto;
- A camada [business] é independente da camada [dao] e nunca a chama;
6.3.1. A classe [Business]
A lógica de cálculo do imposto segue de perto a da classe PHP do curso “Introduction to the PHP7 Language Through Examples” — não a detalharemos de novo aqui; interessa-nos apenas sua tradução para TypeScript:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | |
- linha 8: taxAdminData: any — a estrutura exata dos dados enviados pelo servidor de impostos (alíquotas, faixas etc.) não está documentada; por isso permanecemos deliberadamente flexíveis quanto a esse tipo, em vez de especular sobre uma interface incerta;
- A classe [Business] é exportada, linha 191;
6.3.2. A classe [Dao2]

A classe [Dao2] implementa a camada [dao] do cliente JavaScript acima da seguinte forma:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | |
Comentários
- A classe [Dao2] implementa apenas três das requisições possíveis ao servidor de cálculo de imposto:
- [init-session] (linhas 21–35): para inicializar a sessão jSON;
- [authenticate-user] (linhas 37–57): para autenticar;
- [get-admindata] (linhas 59–73): para recuperar os dados da administração tributária que permitirão realizar os cálculos de imposto no lado do cliente;
Usaremos agora o Postman (veja a seção “Testes com o Postman”) para demonstrar como funciona a ação [get-admindata]. Se ainda não o fez, importe (Ctrl-O) a coleção de requisições HTTP — armazenada no arquivo [tax-servers-tests.postman_collection.json] da pasta [php_server] — no Postman:
![]() | ![]() |
Em seguida, execute em ordem as três requisições [2-4] listadas acima.
A requisição [4] é a seguinte:
![]() |
O resultado dessa requisição é o seguinte:
O conteúdo das duas tabelas do banco de dados está disponível na forma jSON.
6.3.3. O script [main2]

Este script inicializa a sessão, autentica, recupera os dados fiscais e depois realiza os cálculos de imposto localmente por meio da camada business — esses cálculos não envolvem mais o servidor:
- linha 30: taxAdminData = response.response — os dados fiscais, recebidos do servidor uma única vez, são então reutilizados localmente em todos os cálculos;
- linha 39: const business = new Business(taxAdminData) — a camada de negócio é instanciada com esses dados, sem nunca fazer outra requisição de rede;
- linhas 44–46: os três cálculos de imposto agora são síncronos, executados diretamente no navegador ou no node.js, sem passar pelo servidor.
Resultado da execução:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | |
6.4. Cliente HTTP 3
![]() |
Nesta seção, executamos a aplicação [HTTP client 2] em um navegador segundo a seguinte arquitetura:

Enquanto o [node.js] executa TypeScript nativamente por meio do tsx, isso não ocorre nos navegadores: é necessária uma ferramenta para compilar o TypeScript em JavaScript e depois reunir tudo em um único arquivo utilizável por uma página HTML. Esse é o papel do [webpack].
Nota: A operação [1] descrita acima será uma requisição HTTP gerada pelo código JavaScript de uma página HTML. Veremos em breve que essa página HTML é obtida pela URL [http://localhost:8080] (ou 8081), solicitada a um servidor interno iniciado pelo [webpack]. O servidor de cálculo de imposto, por sua vez, é uma aplicação NestJS acessível na URL [http://localhost:3000] (veja Instalação de um servidor NestJS). Temos, portanto, duas aplicações web se comunicando, ambas acessadas por [http://localhost], mas não pela mesma porta. Dizemos que estão em domínios diferentes. Esse tipo de requisição entre duas aplicações web em domínios diferentes é controlado. Por padrão, o servidor NestJS rejeitará requisições de um cliente web se o cliente não compartilhar a mesma origem do servidor, isto é, [http://localhost:3000]. No entanto, é possível configurar o servidor NestJS para aceitar essas requisições chamadas “cross-domain”. Isso foi feito aqui. É por isso que o cliente JavaScript mostrado a seguir funcionará. Você pode ver a configuração do servidor NestJS no capítulo “Estudo de caso: o servidor de cálculo de imposto em NestJS”, que mostra como configurá-lo para aceitar requisições cross-domain.
6.4.1. Mudanças no conjunto de ferramentas desde 2019
O documento original (2019) usava o [babel-loader] para transpilar o código ES6 em ES5, compatível com navegadores antigos. Como nosso projeto agora é escrito em TypeScript, substituímos o babel-loader pelo [ts-loader], que suporta nativamente a sintaxe do TypeScript (tipos, interfaces etc.) — algo que o Babel ignora completamente.
O arquivo [webpack.config.js] do projeto (pasta tax client/http client 3) configura o módulo [webpack]:
- linha 36: entry: "./src/index.ts" — o Webpack parte desse arquivo e segue todas as suas importações para construir o bundle final;
- linhas 42–44: resolve: { extensions: [".ts", ".js"] } — instrui o Webpack a resolver também arquivos .ts mesmo que a extensão não seja especificada nas importações;
- linhas 48–56: a regra que associa todo arquivo .ts da pasta src ao loader [ts-loader] — este é o substituto direto do babel-loader mencionado acima.
O conteúdo do arquivo [./src/index.ts] é o seguinte:
Tenha em mente que o código JavaScript será executado em um navegador. Portanto, a linha anterior não será escrita em um terminal, mas no console do navegador que executa esse código.
O arquivo [package.json] deste subprojeto é o seguinte. Ele tem seus próprios scripts e dependências (ts-loader, TypeScript, além de core-js e regenerator-runtime, que são polyfills para garantir a compatibilidade com navegadores antigos):
- linhas 12–20: dependências necessárias durante o desenvolvimento do projeto (compilação);
-
linhas 21–26: dependências necessárias durante a execução do projeto;
-
linha 17: [webpack]: o orquestrador. [webpack] realiza a transpilação dos códigos TypeScript → ES5 e depois reúne todos os arquivos resultantes em um único arquivo;
- linha 18: [webpack-cli]: exigido pelo [webpack];
- linha 13: [@webpack-cli/init]: usado para configurar o [webpack];
- linha 19: [webpack-dev-server]: fornece um servidor web de desenvolvimento que roda por padrão nas portas 8080 ou 8081. Quando os arquivos-fonte são modificados, o [webpack-dev-server] recarrega automaticamente a aplicação web;
6.4.2. Compilação e execução do projeto
O arquivo [package.json] define três tarefas [npm]:
Essas tarefas são reconhecidas pelo [VSCode], que as oferece para execução. Passe o mouse sobre a tarefa “build” na linha 3:
![]() |
Basta clicar em [Run Script] para executar a tarefa selecionada. Você também pode digitar o seguinte comando:
em um terminal localizado na pasta que contém o arquivo [package.json].
A tarefa [build] cria uma pasta chamada [dist] (1) no projeto VSCode:
![]() |
- Em [3]: o projeto é compilado em [dist/main.hash.js], e uma página chamada [dist/index.html] é criada (2);
A página gerada [index.html] é a seguinte:
Essa página, portanto, apenas encapsula o arquivo [main.hash.js] gerado pelo [webpack].
O projeto é executado pela tarefa [start]:
A página [dist/index.html] é então carregada em um servidor — parte do conjunto [webpack] — que roda na porta 8080 ou 8081 da máquina local e é exibida no navegador padrão da máquina:
![]() |
- em [2], a porta de serviço do servidor web do [webpack];
- em [3-4], a aba [console] das ferramentas de desenvolvedor do navegador, neste caso o Microsoft Edge (acionadas com F12);
- em [5], o resultado da execução do arquivo [src/index.ts]. Lembre-se de que o conteúdo desse arquivo era o seguinte:
Agora, vamos alterar esse conteúdo para a seguinte linha em [index.ts]:
e salve o arquivo. Automaticamente (sem recompilar), um novo arquivo chamado [index.html] é gerado, e esse novo arquivo, [index.html], é carregado no navegador:
![]() |
Não é necessário executar a tarefa [build] antes da tarefa [start]: esta última compila primeiro o projeto. Ela não armazena o resultado dessa compilação na pasta [dist]. Para verificar, basta excluir essa pasta. Você verá então que a tarefa [start] compila e executa o projeto sem criar a pasta [dist]. Ela parece armazenar sua saída [index.html, main.hash.js] em uma pasta específica do [webpack-dev-server]. Esse comportamento é suficiente para os nossos testes.
Enquanto o servidor de desenvolvimento está em execução, qualquer alteração salva em um dos arquivos do projeto dispara uma recompilação. Por isso, desativamos o modo [Auto Save] do [VSCode]. Isso porque não queremos que uma recompilação ocorra a cada caractere digitado em um dos arquivos do projeto. Queremos que a recompilação ocorra apenas quando as alterações são salvas:

- Em [2], a opção [Auto Save] não deve estar marcada;
6.4.3. Teste do cliente web JavaScript do servidor de cálculo de imposto
Para testar o cliente web JavaScript do servidor de cálculo de imposto, você deve especificar [main3.ts] [1] como ponto de entrada do projeto no arquivo [webpack.config.js] [2-3]:
![]() | ![]() |
- Em [1], o script [main3.ts];
- em [2-3], a entrada [entry] a modificar no arquivo de configuração do [webpack];
6.4.3.1. O script [main3]
Este script usa o conteúdo de main2.ts (capítulo anterior), adaptado para um navegador (importação de polyfills):
- Linhas 3–4: import "core-js/stable" e import "regenerator-runtime/runtime" — os polyfills necessários para que o código compilado funcione em navegadores que ainda não implementam nativamente todos os recursos mais recentes da linguagem;
- linha 15: axios.defaults.withCredentials = true — essencial em um navegador para que os cookies de sessão sejam repassados automaticamente entre as requisições, o que o código fazia manualmente nas versões anteriores (o node.js não suporta cookies de navegador).
6.4.3.2. A classe [Dao3]
Como o cookie de sessão agora é gerenciado pelo módulo [axios], podemos remover o tratamento desse cookie da classe [Dao]:
Neste código, não há mais nenhum tratamento de cookies.
6.4.3.3. Compilação e execução
O arquivo package.json define duas tarefas npm:
- [npm run build] — compila o projeto; os arquivos resultantes são colocados em dist/ (um arquivo main.<hash>.js e um arquivo index.html que o integra automaticamente por meio do html-webpack-plugin);
- [npm start] — inicia o webpack-dev-server: compila o projeto e o serve em http://localhost:8080, com recarga automática da página a cada vez que um arquivo-fonte é salvo.
Executamos essas duas tarefas. O resultado na página [console] do navegador (F12) é o seguinte:
![]() |
6.5. Cliente HTML
![]() |
As seções anteriores usaram o cliente [http client 3] exclusivamente em modo console: o script [main3.ts] comunica-se com o servidor e depois exibe seus resultados com console.log, sem nenhuma página visível no navegador. Vamos agora construir um verdadeiro cliente gráfico, completo, com telas (autenticação, cálculo de imposto, lista de simulações).
Partiremos do projeto cliente [http client 3] (mesmos arquivos [package.json] e [tsconfig.json]) e reutilizaremos dois arquivos existentes sem modificá-los: [Dao3.ts] (camada [dao]) e [Business.ts] (camada [business], já abordada a propósito do [main3.ts]). Acrescentamos apenas:
- um arquivo chamado [src/index.html], que serve de template para a página (cabeçalho, estilos CSS, área onde as views são exibidas);
- um novo arquivo, [Views.ts], que constrói os elementos HTML (formulários, tabela, mensagens de erro) diretamente em JavaScript, sem nunca chamar o próprio servidor;
- um novo arquivo, [AppHtml.ts], o controlador da aplicação: ele coordena as camadas [dao] e [business] , e então instrui a camada [views] a exibir o resultado;
- uma pequena modificação em [webpack.config.js] para que o projeto compile esse novo ponto de entrada com o novo template HTML.
O quarteto [dao] / [business] / [views] / controller reproduz, portanto, exatamente a arquitetura em camadas já vista neste curso: a camada [dao] para o acesso ao servidor, a camada [business] para a lógica da aplicação (cálculo do imposto) e o script principal (aqui, a classe [AppHtml]) para a orquestração. Somente a camada [views] é realmente nova: ela substitui a saída no console pela saída no navegador.
6.5.1. Arquitetura da solução
Este cliente HTML funciona exatamente como [main3.ts], e essa é uma escolha de projeto fundamental: ele só chama o servidor (PHP) para três ações, sempre as mesmas: init-session, authenticate-user e get-admindata. No entanto, o código do servidor (PHP) mostra que ele também é capaz de calcular o imposto por conta própria e de armazenar as simulações em sua sessão (são as ações calculate-tax, list-simulations e delete-simulation, encontradas na pasta [Controllers]), mas este cliente não as utiliza.
O motivo é simples: depois que os dados do imposto (alíquotas, faixas etc.) foram obtidos uma única vez com get-admindata, tudo o que é necessário para calcular o imposto já está no navegador, graças à classe [Business] . Pedir esse cálculo ao servidor a cada simulação exigiria uma ida e volta evitável pela rede; da mesma forma, como cada simulação calculada é imediatamente armazenada no navegador, pedir a lista novamente ao servidor (list-simulations) não traria nenhum valor. Este cliente minimiza, portanto, as requisições ao servidor tanto quanto possível, exatamente o princípio já implementado em [main3.ts]:
- a camada [dao] ([Dao3.ts]) permanece inalterada: seus três métodos já apresentados acima (initSession, authenticateUser e getAdminData) são suficientes; nenhum é acrescentado a ela;
- imediatamente após a autenticação bem-sucedida, getAdminData é chamado uma vez por todas, e seu resultado é usado para construir um objeto Business (new Business(taxAdminData)), que é mantido durante toda a sessão de trabalho;
- cada cálculo de imposto chama então diretamente business.calculateTax(married, children, salary), uma função JavaScript comum, executada no navegador, sem nenhuma chamada de rede;
- as simulações calculadas são armazenadas em um simples array JavaScript, mantido em memória pelo controller: um push por cálculo, um splice por exclusão, exatamente como [main3.ts] faz com suas instruções simulations.push(...) e simulations.splice(1, 1).
Uma pequena diferença em relação a [main3.ts]: o método business.calculateTax retorna apenas os valores que calculou (tax, surcharge, discount, reduction, rate), e não os parâmetros informados pelo usuário (married, children, salary). [main3.ts] não precisa deles, pois simplesmente usa console.log; mas nossa view [List of simulations] deve exibir esses três parâmetros na tabela, de modo que o controller os anexa ao próprio resultado antes de armazená-lo (veremos isso no código de [AppHtml.ts]).
Por fim, a view [End of session] também não faz mais nenhuma chamada ao servidor: ela simplesmente descarta o objeto [Business] e a lista de simulações, e depois exibe novamente a tela de autenticação. Lembre-se de que as respostas das três ações do servidor ainda em uso têm sempre o mesmo formato, que já vimos em [main3.ts]: um objeto JSON { action, status, response }, em que response contém o resultado solicitado (em caso de sucesso) ou uma mensagem de erro, uma string ou um array de strings, conforme o controller PHP em questão.
6.5.1.1. O template HTML: o arquivo [src/index.html]
Um projeto [webpack] que usa [html-webpack-plugin] (como é o caso aqui; veja o arquivo [webpack.config.js]) pode partir de uma página HTML pronta, um “template”, na qual o plugin inserirá automaticamente a tag <script> que carrega o bundle compilado. Até agora, este projeto não tinha um template: [html-webpack-plugin] gerava uma página HTML mínima, vazia e sem estilo. Agora passamos a fornecer um: o arquivo [src/index.html], que contém:
- um bloco <style> com toda a formatação da aplicação (cabeçalho, menu, formulários, tabela, mensagens de erro e de resultado);
- uma única tag <div id="app"></div> : é o único elemento HTML “visível” do template; o restante da página (cabeçalho, formulários, tabela etc.) será gerado dinamicamente em JavaScript pela classe [Views], dentro dessa tag.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 | |
Este é um arquivo HTML/CSS padrão, sem nada específico de TypeScript, mas, como o público deste curso é iniciante, vamos examinar em detalhe os pontos mais importantes:
As variáveis CSS (linhas 7 a 16):
- O bloco :root { --name: value; ... } declara variáveis CSS (também chamadas de “propriedades personalizadas”): --light-blue, --light-green etc.;
- elas são então reutilizadas no restante da folha de estilo por meio da função var(...), por exemplo, background: var(--banner-grey); na linha 40;
- A vantagem: alterar a cor uma única vez no início do arquivo basta para mudá-la em todos os lugares em que é usada, em vez de ter de procurar cada código de cor ao longo de todo o arquivo.
A estrutura geral (linhas 29 a 87):
- #app (linha 29) limita a largura da aplicação e adiciona uma borda;
- .banner (linha 36) exibe o logotipo e o título lado a lado com
display: flex; - .page-body (linha 56) divide o restante da página em duas colunas flexíveis: .menu (linha 61, largura fixa de 160 pixels) à esquerda e .content (linha 80, largura variável) à direita; a classe .content.full-width (linha 85) oculta essa coluna de menu na view de login, que não precisa dela.
Classes reutilizadas pela camada [views] (linhas 90 a 210):
- .section-title (linha 90): a caixa azul-clara usada para os títulos “Please authenticate”, “Fill in the form below and then submit it” e “List of your simulations”;
- .field-row (linha 99): uma linha de formulário (rótulo + campo de entrada);
- .result (linha 152): a caixa verde-clara que exibe o resultado de um cálculo de imposto;
- .error (linha 161): a caixa vermelha-clara que exibe uma mensagem de erro retornada pelo servidor;
- table.simulations (linha 171): a formatação da tabela na view “lista de simulações”, com seus links azuis “Delete” (regra table.simulations a.delete, linha 196).
Cada uma dessas classes pode ser encontrada no código da classe [Views] (className = '...' ou classList.add('...')): é essa classe que, em JavaScript, cria os elementos HTML e aplica a eles essas classes CSS.
6.5.1.2. A configuração [webpack.config.js] modificada
O arquivo [webpack.config.js] já foi apresentado na íntegra anteriormente neste capítulo. Duas pequenas alterações bastam para que ele compile este novo cliente gráfico em vez do script de teste [main3.ts]:
- linha 4: entry: "./src/AppHtml.ts" substitui entry: "./src/main3.ts": o novo controller passa a ser o ponto de entrada do bundle; o valor antigo é mantido logo abaixo, como comentário (linhas 5 a 8), para que você possa voltar facilmente ao script de teste, se necessário;
- linhas 21 a 23: new HtmlWebpackPlugin({ template: ... }) substitui new HtmlWebpackPlugin() (sem parâmetros): instruímos o plugin explicitamente a usar nosso template [src/index.html] em vez de gerar uma página HTML vazia.
6.5.1.3. As camadas [dao] e [business] : dois arquivos reutilizados sem modificação
O arquivo [Dao3.ts] não é modificado aqui: seus três métodos já apresentados anteriormente neste capítulo (initSession, authenticateUser, getAdminData, além do utilitário getRemoteData) são exatamente o que este cliente gráfico precisa; nenhum é acrescentado.
[Business.ts] também não é modificado: é a mesma classe [Business], com seu método calculateTax(married, children, salary), que já foi apresentado integralmente na discussão de [main3.ts] (seção [Client HTTP 2]). Este cliente gráfico, porém, é o primeiro deste capítulo a realmente exibir os resultados desse cálculo na tela, em vez de simplesmente registrá-los em log; é uma oportunidade de verificar se a camada [views], apresentada logo a seguir, consegue formatá-los corretamente.
6.5.1.4. A camada [views]: o arquivo [Views.ts]
Este é o arquivo mais longo deste cliente, mas também o mais fácil de entender quando se compreende seu princípio: a classe [Views] não faz nenhuma chamada de rede; ela nem sabe que o servidor PHP existe. Sua única finalidade é construir, usando as funções do DOM (document.createElement, appendChild, classList...), os elementos HTML das três telas da aplicação, dentro da tag <div id="app"> do template.
Quando o usuário clica em um botão ou em um link (“Submit”, “Delete”, “End of session” etc.), a classe [Views] também não sabe o que fazer com esse clique: ela simplesmente chama uma função de callback fornecida pelo controller; é o controller, [AppHtml.ts], descrito logo adiante, que decide então o que fazer (chamar o servidor, trocar de view etc.). Esse desacoplamento é o que permite que [Views.ts] permaneça independente da camada [dao].
'use strict';
// -----------------------------------------------------------------------
// construção das views (DOM) da aplicação - modeladas a partir das
// capturas de tela do documento [web_application_views.odt]:
// - view de autenticação
// - view de cálculo do imposto (formulário + resultado)
// - view da lista de simulações
// Este módulo não faz nenhuma chamada de rede: ele constrói o DOM e delega
// as ações do usuário (Submit, Delete, links do menu) a funções de
// callback fornecidas pelo controller [App].
// -----------------------------------------------------------------------
// uma decoração genérica (não a foto do servidor PHP original, que não
// temos): substitua-a, se necessário, pelo logotipo real em [Resources/]
const LOGO_SVG = `
<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
<circle cx="30" cy="30" r="29" fill="#eef1ec" stroke="#ccc" />
<g fill="none" stroke="#8a9a7a" stroke-width="2">
<path d="M30 46 C30 32 22 28 17 19" />
<path d="M30 46 C30 30 39 26 44 17" />
<path d="M30 46 C30 37 30 30 30 21" />
</g>
<g fill="#b9c9a6">
<circle cx="17" cy="19" r="4.5" />
<circle cx="44" cy="17" r="4.5" />
<circle cx="30" cy="19" r="4.5" />
</g>
</svg>`;
// resultado de um cálculo de imposto, conforme retornado pelo servidor (veja [Simulation.php])
export interface Simulation {
married: string;
children: number;
salary: number;
tax: number;
surcharge: number;
discount: number;
reduction: number;
rate: number;
}
// callbacks da view [authentication]
export interface AuthenticationCallbacks {
onSubmit: (user: string, password: string) => void;
}
// callbacks da view [calculation]
export interface CalculationCallbacks {
onSubmit: (married: string, children: number, salary: number) => void;
onList: () => void;
onEndSession: () => void;
}
// callbacks da view [list]
export interface ListCallbacks {
onDelete: (number: number) => void;
onCalculation: () => void;
onEndSession: () => void;
}
class Views {
private banner: HTMLElement;
private menu: HTMLElement;
private content: HTMLElement;
// constrói a estrutura fixa da página (banner + área de menu/conteúdo)
// dentro do elemento [root]
constructor(private root: HTMLElement) {
this.root.innerHTML = '';
this.banner = document.createElement('div');
this.banner.className = 'banner';
const logo = document.createElement('div');
logo.className = 'logo';
logo.innerHTML = LOGO_SVG;
const title = document.createElement('h1');
title.textContent = 'Calculate your tax';
this.banner.appendChild(logo);
this.banner.appendChild(title);
const body = document.createElement('div');
body.className = 'page-body';
this.menu = document.createElement('div');
this.menu.className = 'menu';
this.content = document.createElement('div');
this.content.className = 'content';
body.appendChild(this.menu);
body.appendChild(this.content);
this.root.appendChild(this.banner);
this.root.appendChild(body);
}
// --------------------------------------------------------------------
// ferramentas de construção do DOM
// --------------------------------------------------------------------
private clearMenu(): void {
this.menu.innerHTML = '';
this.menu.style.display = 'none';
this.content.classList.add('full-width');
}
private menuLink(text: string, onClick: () => void): HTMLAnchorElement {
const a = document.createElement('a');
a.textContent = text;
a.addEventListener('click', onClick);
return a;
}
private showMenu(links: HTMLAnchorElement[]): void {
this.menu.innerHTML = '';
this.menu.style.display = '';
this.content.classList.remove('full-width');
links.forEach(link => this.menu.appendChild(link));
}
private errorBanner(message?: string): HTMLElement | null {
if (!message) {
return null;
}
const div = document.createElement('div');
div.className = 'error';
div.textContent = message;
return div;
}
// uma linha de formulário [rótulo + campo de texto/senha/número]
private fieldRow(
labelText: string,
type: 'text' | 'password' | 'number',
initialValue: string,
help?: string
): { row: HTMLElement; input: HTMLInputElement } {
const row = document.createElement('div');
row.className = 'field-row';
const label = document.createElement('label');
label.textContent = labelText;
const field = document.createElement('div');
field.className = 'field';
const input = document.createElement('input');
input.type = type;
input.value = initialValue;
if (type === 'number') {
input.min = '0';
}
field.appendChild(input);
if (help) {
const div = document.createElement('div');
div.className = 'help';
div.textContent = help;
field.appendChild(div);
}
row.appendChild(label);
row.appendChild(field);
return { row, input };
}
// --------------------------------------------------------------------
// view de [autenticação]
// --------------------------------------------------------------------
authenticationView(error: string | undefined, callbacks: AuthenticationCallbacks): void {
this.clearMenu();
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'Please authenticate';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
const userField = this.fieldRow("User name", 'text', 'admin');
const passwordField = this.fieldRow('Password', 'password', '');
this.content.appendChild(userField.row);
this.content.appendChild(passwordField.row);
const button = document.createElement('button');
button.textContent = 'Submit';
button.addEventListener('click', () => {
callbacks.onSubmit(userField.input.value.trim(), passwordField.input.value);
});
this.content.appendChild(button);
}
// --------------------------------------------------------------------
// view de [cálculo de imposto]
// --------------------------------------------------------------------
calculationView(
result: Simulation | undefined,
error: string | undefined,
callbacks: CalculationCallbacks
): void {
this.showMenu([
this.menuLink('List of simulations', callbacks.onList),
this.menuLink('End of session', callbacks.onEndSession)
]);
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'Fill in the form below and then submit it';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
// linha dos radios [married]
const marriedRow = document.createElement('div');
marriedRow.className = 'field-row';
const marriedLabel = document.createElement('label');
marriedLabel.textContent = 'Are you married or in a civil partnership?';
const marriedField = document.createElement('div');
marriedField.className = 'field radios';
const radioYes = document.createElement('input');
radioYes.type = 'radio';
radioYes.name = 'married';
radioYes.value = 'yes';
radioYes.checked = true;
const labelYes = document.createElement('label');
labelYes.appendChild(radioYes);
labelYes.appendChild(document.createTextNode(' Yes'));
const radioNo = document.createElement('input');
radioNo.type = 'radio';
radioNo.name = 'married';
radioNo.value = 'no';
const labelNo = document.createElement('label');
labelNo.appendChild(radioNo);
labelNo.appendChild(document.createTextNode(' No'));
marriedField.appendChild(labelYes);
marriedField.appendChild(labelNo);
marriedRow.appendChild(marriedLabel);
marriedRow.appendChild(marriedField);
this.content.appendChild(marriedRow);
const childrenField = this.fieldRow("Number of dependent children", 'number', '0');
this.content.appendChild(childrenField.row);
const salaryField = this.fieldRow('Annual salary', 'number', '', "Round down to the nearest euro");
this.content.appendChild(salaryField.row);
const button = document.createElement('button');
button.textContent = 'Submit';
button.addEventListener('click', () => {
const married = radioYes.checked ? 'yes' : 'no';
const children = parseInt(childrenField.input.value, 10) || 0;
const salary = parseInt(salaryField.input.value, 10) || 0;
callbacks.onSubmit(married, children, salary);
});
this.content.appendChild(button);
// resultado da última simulação (caixa verde), se houver
if (result) {
const box = document.createElement('div');
box.className = 'result';
const ratePercent = Math.round(result.rate * 100);
box.innerHTML =
`Tax amount: ${result.tax} euros<br>` +
`Discount: ${result.discount} euros<br>` +
`Reduction: ${result.reduction} euros<br>` +
`Surcharge: ${result.surcharge} euros<br>` +
`Tax rate: ${ratePercent} %`;
this.content.appendChild(box);
}
}
// --------------------------------------------------------------------
// view de [lista de simulações]
// --------------------------------------------------------------------
listView(
simulations: Simulation[],
error: string | undefined,
callbacks: ListCallbacks
): void {
this.showMenu([
this.menuLink("Tax calculation", callbacks.onCalculation),
this.menuLink('End of session', callbacks.onEndSession)
]);
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'List of your simulations';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
if (simulations.length === 0) {
const empty = document.createElement('div');
empty.className = 'simulations-empty';
empty.textContent = 'No simulation recorded.';
this.content.appendChild(empty);
return;
}
const table = document.createElement('table');
table.className = 'simulations';
const thead = document.createElement('thead');
thead.innerHTML =
'<tr><th>#</th><th>Married</th><th>Number of children</th><th>Annual salary</th>' +
'<th>Tax amount</th><th>Surcharge</th><th>Discount</th><th>Reduction</th><th>Rate</th><th></th></tr>';
table.appendChild(thead);
const tbody = document.createElement('tbody');
simulations.forEach((simulation, number) => {
const tr = document.createElement('tr');
const ratePercent = Math.round(simulation.rate * 100);
tr.innerHTML =
`<td>${number}</td>` +
`<td>${simulation.married}</td>` +
`<td>${simulation.children}</td>` +
`<td>${simulation.salary}</td>` +
`<td>${simulation.tax}</td>` +
`<td>${simulation.surcharge}</td>` +
`<td>${simulation.discount}</td>` +
`<td>${simulation.reduction}</td>` +
`<td>${ratePercent} %</td>`;
const tdDelete = document.createElement('td');
const deleteLink = document.createElement('a');
deleteLink.className = 'delete';
deleteLink.textContent = 'Delete';
deleteLink.addEventListener('click', () => callbacks.onDelete(number));
tdDelete.appendChild(deleteLink);
tr.appendChild(tdDelete);
tbody.appendChild(tr);
});
table.appendChild(tbody);
this.content.appendChild(table);
}
}
// exportação da classe
export default Views;
O logotipo e as interfaces TypeScript (linhas 1 a 60):
- Linhas 16 a 29: LOGO_SVG é uma string de várias linhas (delimitada por acentos graves \ \, uma “template string”) que contém um pequeno desenho vetorial genérico (SVG), usado no lugar da imagem original do servidor PHP, que não foi incluída no projeto TypeScript;
- linhas 32 a 41: a interface Simulation descreve o formato de uma simulação conforme retornada pelo servidor; ela contém exatamente os mesmos nomes de campos que as classes PHP e [Simulation.php] (married, children, salary, tax, surcharge, discount, reduction, rate);
- linhas 44 a 60: as três interfaces Callbacks... descrevem, para cada view, as funções de callback que o controller deve fornecer (por exemplo, onSubmit, chamada quando o usuário clica no botão “Submit”).
O construtor (linhas 62 a 94):
- linha 70: o construtor recebe o elemento HTML raiz (root, a tag <div id="app"> do template); a palavra-chave
privateantes do parâmetro é um atalho que cria automaticamente um atributorootsem que seja preciso escreverthis.root = root;; - linhas 73 a 81: construção do banner (div.banner), com o logotipo e o título <h1>Calculate your tax</h1> ;
- linhas 83 a 90: construção do corpo da página (div.page-body), que sempre contém dois campos, this.menu e this.content; são propriedades do objeto (linhas 64 a 66), guardadas em memória para que possam ser esvaziadas e preenchidas a cada troca de view;
- linhas 92 e 93: o cabeçalho e o corpo são, por fim, adicionados à raiz da página.
Métodos utilitários privados (linhas 96 a 159):
- clearMenu (linhas 100 a 104): oculta a coluna do menu e adiciona a classe CSS full-width à área de conteúdo; é usado pela view de autenticação, que não tem menu;
- menuLink (linhas 106 a 111): cria um link <a> com seu texto e sua função de callback de clique; é um pequeno método de fábrica reutilizado para construir cada link do menu (“List of simulations”, “End of session” etc.);
- showMenu (linhas 113 a 118): exibe a coluna do menu e coloca nela os links recebidos como parâmetros (um array de links já construídos com menuLink);
- errorBanner (linhas 120 a 128): cria a caixa vermelha de erro (classe CSS error) se uma mensagem de erro for fornecida, ou não retorna nada (null) caso contrário;
- fieldRow (linhas 130 a 159): a fábrica mais usada do arquivo; ela constrói uma linha de formulário completa (rótulo + campo de entrada, com texto de ajuda opcional) e retorna tanto a linha completa (line) quanto apenas o campo de entrada (input), para que o chamador possa depois ler o valor digitado pelo usuário.
O método authenticationView (linhas 161 a 189):
- linhas 165 e 166: a view sempre começa limpando o menu e o conteúdo da view anterior;
- linhas 168 a 171: a caixa azul “Please authenticate”;
- linhas 173 a 176: o banner de erro, exibido somente se
errornão estiver vazio (ou seja, somente após uma tentativa de autenticação malsucedida); - linhas 178 a 181: os dois campos do formulário, construídos com fieldRow;
- linhas 183 a 188: o botão “Submit”; seu tratador de clique (linhas 185 a 187) chama callbacks.onSubmit(...) com o conteúdo dos dois campos de entrada; isso é tudo o que esta classe faz: ela não valida nem envia nada por conta própria, apenas repassa o que o usuário digitou.
O método calculationView (linhas 191 a 276):
- linhas 199 a 202: diferentemente da view anterior, esta exibe um menu com os links “List of simulations” e “End of session”;
- linhas 217 a 245: criação dos dois botões de opção “Yes”/“No” (“Are you married or in a civil partnership?”), um pouco mais longa que a dos outros campos porque os botões de opção não têm um gerador genérico como fieldRow;
- linhas 247 a 251: os campos “Number of dependent children” e “Annual salary”, construídos com fieldRow;
- linhas 253 a 261: o botão “Submit”; seu tratador de clique lê o estado dos botões de opção e o conteúdo dos dois campos numéricos (com parseInt, pois o valor de um campo HTML é sempre uma string) e, em seguida, chama callbacks.onSubmit(married, children, salary);
- linhas 264 a 275: se um result tiver sido retornado (ou seja, após um cálculo bem-sucedido), a caixa verde é criada e preenchida com as cinco informações da simulação; result.rate é um número entre 0 e 1 (por exemplo, 0.14) que a linha 267 converte em uma porcentagem arredondada (14) para exibição.
O método listView (linhas 278 a 344):
- linhas 286 a 289: o menu desta view oferece “Tax calculation” (para voltar) e “End of session”;
- linhas 303 a 309: caso especial em que a lista está vazia; uma mensagem simples é exibida (“No simulation recorded.”) e o método termina aí (return), sem construir a tabela;
- linhas 311 a 317: construção do cabeçalho da tabela (<thead>), com uma coluna por campo de uma simulação, mais uma última coluna vazia para o link “Delete”;
- linhas 319 a 341: uma linha da tabela (<tr>) é construída para cada simulação, usando simulations.forEach(...) ; o segundo parâmetro dessa função, “number”, é automaticamente o índice (começando em 0) da simulação no array, que é exatamente o número esperado pela ação do servidor “delete-simulation”;
- linhas 333 a 339: o link “Delete” de cada linha; seu tratador de clique (linha 337) chama callbacks.onDelete(number) com o número da linha em questão.
6.5.1.5. O controller: o arquivo [AppHtml.ts]
Este é o orquestrador da aplicação: ele assume o papel desempenhado pela função main() de **[main3.ts], mas na forma de uma classe, com um método por view. Agora ele coordena duas camadas, [dao] (o servidor) e [business] (o cálculo), antes de instruir a camada [views]** a exibir um resultado ou uma mensagem de erro:
// importações
import axios from 'axios';
import "core-js/stable";
import "regenerator-runtime/runtime";
// importações
import Dao from './Dao3';
import Business from './Business';
import Views, { Simulation } from './Views';
// -----------------------------------------------------------------------
// controller da aplicação HTML: orquestra as chamadas ao servidor
// (camada [dao]), os cálculos (camada [business]) e a exibição das views
// (camada [views]).
//
// Como [main3.ts], este cliente só chama o servidor PHP para três
// ações: [init-session], [authenticate-user] e [get-admindata].
// Depois que os dados do imposto (alíquotas, tetos...) foram obtidos com
// [get-admindata], é a camada [business] (classe [Business], o mesmo
// arquivo [Business.ts] de [main3.ts]) que calcula o imposto no
// navegador, sem nenhuma nova chamada de rede. A lista de simulações também
// é mantida apenas no navegador (array [this.simulations]),
// exatamente como [main3.ts] faz com seu array local [simulations]
// (veja `simulations.push(...)` e `simulations.splice(...)`).
// -----------------------------------------------------------------------
class AppHtml {
private dao: Dao;
private views: Views;
// camada [business]: só existe depois que os dados de imposto são recuperados
// (após uma autenticação bem-sucedida) - veja [initBusiness]
private business?: Business;
// lista das simulações já calculadas, mantida no navegador
private simulations: Simulation[] = [];
constructor() {
// configuração do axios - idêntica a [main3.ts]
axios.defaults.timeout = 5000;
axios.defaults.baseURL = 'http://localhost/';
axios.defaults.withCredentials = true;
// camadas [dao] e [views]
this.dao = new Dao(axios);
this.views = new Views(document.getElementById('app')!);
}
// ponto de entrada da aplicação
async start(): Promise<void> {
try {
// init session - obrigatório antes de qualquer outra ação (veja [main.php])
const response = await this.dao.initSession();
if (response.status !== 700) {
this.views.authenticationView(this.formatError(response.response), {
onSubmit: (user, password) => this.authenticate(user, password)
});
return;
}
} catch (error: any) {
this.views.authenticationView(
"Unable to contact the server (" + error.message + ")",
{ onSubmit: (user, password) => this.authenticate(user, password) }
);
return;
}
// sessão inicializada: exibimos a autenticação
this.showAuthentication();
}
// --------------------------------------------------------------------
// view de [autenticação]
// --------------------------------------------------------------------
private showAuthentication(error?: string): void {
this.views.authenticationView(error, {
onSubmit: (user, password) => this.authenticate(user, password)
});
}
private async authenticate(user: string, password: string): Promise<void> {
try {
const response = await this.dao.authenticateUser(user, password);
if (response.status === 200) {
// autenticação bem-sucedida: como em [main3.ts], recuperamos agora,
// de uma vez por todas, os dados de imposto
// necessários à camada [business]
await this.initBusiness();
} else {
// falha (login/senha incorretos, ou parâmetros ausentes)
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// recupera os dados da administração fiscal e instancia a camada
// [business] com esses dados - uma única chamada ao servidor para a sessão inteira,
// exatamente como [main3.ts]
private async initBusiness(): Promise<void> {
try {
const response = await this.dao.getAdminData();
if (response.status === 1000) {
this.business = new Business(response.response);
// nova sessão de trabalho: recomeçamos de uma lista vazia
this.simulations = [];
this.showCalculation();
} else {
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// --------------------------------------------------------------------
// view de [cálculo de imposto]
// --------------------------------------------------------------------
private showCalculation(result?: Simulation, error?: string): void {
this.views.calculationView(result, error, {
onSubmit: (married, children, salary) => this.calculate(married, children, salary),
onList: () => this.showList(),
onEndSession: () => this.endSession()
});
}
// cálculo de imposto feito inteiramente no navegador (camada [business]):
// sem chamada ao servidor, ao contrário da primeira versão deste cliente
private calculate(married: string, children: number, salary: number): void {
// this.business necessariamente foi inicializado: só chegamos à
// view de [cálculo] depois de [initBusiness]
const result = this.business!.calculateTax(married, children, salary);
// o resultado retornado por [business.calculateTax] contém apenas os valores
// calculados (tax, surcharge, discount, reduction, rate): adicionamos a ele
// os parâmetros informados pelo usuário, para que possam ser
// exibidos novamente na lista de simulações
const simulation: Simulation = { married: married, children: children, salary: salary, ...result };
// armazenamento no navegador (como `simulations.push(...)` em [main3.ts])
this.simulations.push(simulation);
this.showCalculation(simulation);
}
// --------------------------------------------------------------------
// view de [lista de simulações]
// --------------------------------------------------------------------
// não há mais chamadas ao servidor aqui: a lista já está inteiramente em
// [this.simulations]
private showList(error?: string): void {
this.views.listView(this.simulations, error, {
onDelete: (number) => this.deleteSimulation(number),
onCalculation: () => this.showCalculation(),
onEndSession: () => this.endSession()
});
}
private deleteSimulation(number: number): void {
// exclusão local no array [this.simulations], como
// `simulations.splice(1, 1)` em [main3.ts] - ainda sem chamada ao servidor
this.simulations.splice(number, 1);
this.showList();
}
// --------------------------------------------------------------------
// fim da sessão
// --------------------------------------------------------------------
private endSession(): void {
// fim da sessão apenas no lado do cliente: esquecemos a camada [business]
// (e portanto os dados de imposto) e as simulações já calculadas, depois
// voltamos à tela de autenticação. Este cliente não precisa
// chamar o servidor para isso.
this.business = undefined;
this.simulations = [];
this.showAuthentication();
}
// --------------------------------------------------------------------
// formata o campo [response] de uma resposta de erro do servidor,
// que é uma string ou um array de strings (veja os controllers PHP)
// --------------------------------------------------------------------
private formatError(response: unknown): string {
if (Array.isArray(response)) {
return response.join(' ; ');
}
return String(response);
}
}
// execução
window.addEventListener('DOMContentLoaded', () => {
new AppHtml().start();
});
O comentário de cabeçalho (linhas 11 a 25):
- Ele resume toda a filosofia deste controller, conforme explicado anteriormente: apenas três ações do servidor são usadas; o cálculo é realizado pela camada [business] no navegador; e a lista de simulações é um simples array armazenado no lado do cliente. Um comentário como este, no início do arquivo, é um bom hábito a adotar: ele dá imediatamente ao leitor uma visão geral antes de mergulhar nos detalhes do código.
Os campos da classe e o construtor (linhas 26 a 44):
- linhas 28 e 29: dao e views, já presentes na primeira versão deste cliente;
- linhas 30 a 32: novo campo business, do tipo Business; o ponto de interrogação (?) o torna um campo opcional: enquanto o usuário não se autentica, essa propriedade ainda não tem valor (é undefined);
- linhas 33 e 34: novo campo “simulations”; o array (inicialmente vazio, = []) substitui as antigas chamadas ao servidor “list-simulations” e “delete-simulation”;
- linhas 38 a 40: configuração do [axios], idêntica à de [main3.ts]; em particular, withCredentials = true, que é essencial para que o cookie de sessão seja enviado em cada requisição;
- Linhas 42 e 43: instanciação das camadas [dao] e [views] , sem alterações em relação à versão anterior.
O ponto de entrada, **start (linhas 47 a 66):**
- Linha 50: a primeira coisa que a aplicação faz é chamar
init-session, que é obrigatória antes de qualquer outra ação (veja o arquivo PHP [main.php], que bloqueia qualquer ação até que uma sessão tenha sido inicializada); - linhas 51 a 56: em caso de falha (status diferente de 700), a view de autenticação é exibida de qualquer forma, junto com a mensagem de erro retornada pelo servidor;
- linhas 57 a 63: o bloco
catchtrata o caso em que o servidor está completamente inacessível (servidor fora do ar, URL inválida etc.), um erro de rede, distinto de uma simples resposta de erro do servidor; - Linha 65: se tudo correu bem, a view de autenticação é finalmente exibida sem mensagem de erro; nesta etapa, este método permanece idêntico ao da versão anterior.
A view de autenticação e a inicialização da camada [business] (linhas 71 a 111):
- showAuthentication (linhas 71 a 75): inalterado; ele apenas instrui a camada [views] a exibir essa view, usando o método
authenticatecomo callback por meio de onSubmit; - authenticate (linhas 77 a 92): chama dao.authenticateUser(user, password); se o status for 200, a view de cálculo não é mais exibida diretamente como antes; em vez disso, agora é chamado this.initBusiness() (linha 84), um método novo; em caso de falha, a view de autenticação é exibida novamente com a mensagem de erro (linha 87), sem alterações;
- initBusiness (linhas 97 a 111), um método novo: ele chama dao.getAdminData(), que é o único lugar em todo o arquivo em que essa ação é solicitada ao servidor, uma vez por todas; se o status for 1000, ele cria o objeto Business com os dados recebidos (linha 101, new Business(response.response)), reinicia o array de simulações (linha 103; uma nova autenticação corresponde a uma nova sessão de trabalho) e, por fim, exibe a view de cálculo (linha 104).
A view de cálculo do imposto (linhas 116 a 138):
- showCalculation (linhas 116 a 122): inalterado; pode ser chamado com ou sem um resultado: sem resultado para um formulário vazio (primeira visita ou retorno da lista) e com resultado imediatamente após um cálculo bem-sucedido;
- calculate (linhas 126 a 138): é o método que mais mudou. Ele não é mais assíncrono e não contém mais um bloco try/catch de rede, já que não faz mais nenhuma chamada ao servidor; na linha 129, this.business!.calculateTax(married, children, salary) calcula diretamente o resultado; o ponto de exclamação (!) informa ao TypeScript que temos certeza de que
businessjá foi inicializado (só é possível chegar a esta view depois de initBusiness); nas linhas 130 a 134, como esse resultado não contém os parâmetros informados, eles são anexados a ele com o operador de espalhamento ...result para construir o objeto simulation completo; na linha 136, this.simulations.push(simulation) armazena essa nova simulação no array do navegador; na linha 137, a view é finalmente redesenhada com esse resultado.
A view da lista de simulações (linhas 145 a 158):
- showList (linhas 145 a 151): não faz mais nenhuma chamada ao servidor; ele passa diretamente this.simulations, o array já em memória, para a camada [views];
- deleteSimulation (linhas 153 a 158): na linha 156, this.simulations.splice(number, 1) remove a simulação diretamente do array do navegador, o equivalente exato da instrução simulations.splice(1, 1) em [main3.ts]; em seguida, na linha 157, a lista (atualizada) é exibida novamente.
Fim da sessão e ponto de entrada (linhas 163 a 189):
- endSession (linhas 163 a 171): ele não chama mais dao.endSession() (esse método foi removido de [Dao3.ts]); ele simplesmente descarta a camada [business] (linha 168, this.business = undefined) e as simulações (linha 169, this.simulations = []) e depois exibe novamente a tela de autenticação (linha 170); como o restante deste cliente, encerrar a sessão não exige, portanto, nenhuma requisição de rede;
- formatError (linhas 177 a 182): inalterado; o campo response de um erro do servidor (PHP) às vezes é uma string e às vezes um array de strings (conforme o controller); este método sempre reduz a mensagem a uma única string, pronta para ser exibida;
- Linhas 186 a 188: o ponto de entrada do script, fora da classe, permanece inalterado; DOMContentLoaded garante que a página HTML esteja totalmente carregada antes de criar o controller e chamar start(); é o equivalente, para este cliente com interface gráfica, da chamada
main();no final de [main3.ts].
6.5.1.6. Compilação e execução
A compilação e a execução são feitas exatamente como na seção anterior ([npm run build] ou [npm start]): apenas o ponto de entrada mudou em [webpack.config.js]. Eis as três telas obtidas, para serem comparadas com as capturas de tela do documento [web_application_views.odt] fornecido no início:

Tela de autenticação: o nome de usuário vem preenchido com “admin” por conveniência; se a autenticação falhar, uma mensagem de erro aparece aqui, acima do formulário.

Tela de cálculo do imposto, após o envio do primeiro formulário: a caixa verde exibe o resultado calculado no navegador pela camada [business] (tax, discount, reduction, surcharge, rate, aqui convertido em porcentagem).

Tela "List of your simulations", acessada ao clicar no link "List of simulations": cada linha corresponde a uma simulação armazenada no array do navegador [this.simulations], com seu link "Delete".
As cinco views são as seguintes: autenticação, cálculo com resultados, lista de simulações, exclusão de uma simulação (que reexibe a lista atualizada) e fim da sessão (que volta à tela de autenticação), tudo isso sem jamais fazer requisições ao servidor PHP além das três ações: init-session, authenticate-user, e get-admindata.
6.6. Conclusão
Este capítulo mostrou como a mesma base de lógica de negócio (camadas DAO e business ) pode ser executada tanto pela linha de comando (node.js, capítulos “Client HTTP 1” e “Client HTTP 2”) quanto em um navegador (capítulo “Client HTTP 3”), usando uma ferramenta de compilação adequada, neste caso, o webpack e ts-loader. Essa base TypeScript é o ponto de partida dos frameworks front-end modernos (React, Vue, Angular...), que se apoiam nos mesmos blocos de construção: módulos, classes, async/await e uma ferramenta de build que os reúne para o navegador.











