Skip to content

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

Image

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:

Image

Examinaremos duas versões do cliente:

  • A versão 1 do cliente terá a seguinte estrutura em camadas: [main, dao]:

Image

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

Image

6.2. Cliente HTTP 1

Image

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

Image

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]:

'use strict';

// importações
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao1 {

  private axios: AxiosInstance;
  private sessionCookieName: string;
  private sessionCookie: string;

  // construtor
  constructor(axios: AxiosInstance) {
    // biblioteca axios usada para fazer as requisições HTTP
    this.axios = axios;
    // cookie de sessão
    this.sessionCookieName = "PHPSESSID";
    this.sessionCookie = '';
  }

  // inicialização da sessão
  async initSession(): Promise<any> {
    // opções da requisição HTTP [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      // [atualização TypeScript] URL incluída em [options.url] (veja getRemoteData)
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // opções da requisição HTTP [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // corpo do POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // parâmetros da URL
      params: {
        action: 'authenticate-user'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  // cálculo do imposto
  async calculateTax(married: string, children: number, salary: number): Promise<any> {
    // opções da requisição HTTP
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // corpo do POST
      data: qs.stringify({
        married: married,
        children: children,
        salary: salary
      }),
      // parâmetros da URL
      params: {
        action: 'calculate-tax'
      }
    };
    // execução da requisição HTTP
    const data = await this.getRemoteData(options);
    // resultado
    return data;
  }

  // lista de simulações
  async listSimulations(): Promise<any> {
    // opções da requisição HTTP
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'list-simulations'
      },
    };
    // execução da requisição HTTP
    const data = await this.getRemoteData(options);
    // resultado
    return data;
  }

  // exclusão de uma simulação
  async deleteSimulation(index: number): Promise<any> {
    // opções da requisição HTTP
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'delete-simulation',
        number: index
      },
    };
    // execução da requisição HTTP
    const data = await this.getRemoteData(options);
    // resultado
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // para o cookie de sessão
    if (!options.headers) {
      options.headers = {} as any;
    }
    (options.headers as any).Cookie = this.sessionCookie;
    // execução da requisição HTTP
    let response: AxiosResponse;
    try {
      // requisição assíncrona
      response = await this.axios.request(options);
    } catch (error: any) {
      // o parâmetro [error] é uma instância de exceção - pode assumir várias formas
      if (error.response) {
        // a resposta do servidor está em [error.response]
        response = error.response;
      } else {
        // relançamos o erro
        throw error;
      }
    }
    // response é a resposta HTTP completa do servidor (cabeçalhos HTTP + a própria resposta)
    // recuperamos o cookie de sessão, se existir
    const setCookie = response.headers['set-cookie'];
    if (setCookie) {
      // setCookie é um array
      // procuramos o cookie de sessão nesse array
      let found = false;
      let i = 0;
      while (!found && i < setCookie.length) {
        // procuramos o cookie de sessão
        const results = RegExp('^(' + this.sessionCookieName + '.+?);').exec(setCookie[i]);
        if (results) {
          // armazenamos o cookie de sessão
          // eslint-disable-next-line require-atomic-updates
          this.sessionCookie = results[1];
          // encontramos
          found = true;
        } else {
          // próximo elemento
          i++;
        }
      }
    }
    // a resposta do servidor está em [response.data]
    return response.data;
  }
}

// exportação da classe
export default Dao1;
  • 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:

// importação do axios
import axios from 'axios';
// importação da classe Dao
import Dao from './Dao1.js';


// função [main] assíncrona
async function main(): Promise<void> {
  // configuração do axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost:3000';
  // instanciação da camada [dao]
  const dao = new Dao(axios);
  // uso da camada [dao]
  try {
    // inicialização da sessão
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    // autenticação
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // cálculos de imposto
    log("-----------calculate-tax x 3");
    response = await Promise.all([
      dao.calculateTax("yes", 2, 45000),
      dao.calculateTax("no", 2, 45000),
      dao.calculateTax("no", 1, 30000)
    ]);
    log(response);
    // lista de simulações
    log("-----------list-of-simulations");
    response = await dao.listSimulations();
    log(response);
    // exclusão de uma simulação
    log("-----------deleting simulation no. 1");
    response = await dao.deleteSimulation(1);
    log(response);
  } catch (error: any) {
    // registramos o erro no log
    console.log("error=", error.message);
  }
}

// log JSON
function log(object: unknown): void {
  console.log(JSON.stringify(object, null, 2));
}

// execução
main();

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:

npx tsx main1.ts

Resultado da execução:

"-----------init-session"
{
  "action": "init-session",
  "status": 700,
  "response": "session started with type [json]"
}
"-----------authenticate-user"
{
  "action": "authenticate-user",
  "status": 200,
  "response": "Authentication successful [admin, admin]"
}
"-----------calculate-tax x 3"
[
  {
    "action": "calculate-tax",
    "status": 300,
    "response": {
      "married": "yes",
      "children": "2",
      "salary": "45000",
      "tax": 502,
      "surcharge": 0,
      "discount": 857,
      "reduction": 126,
      "rate": 0.14
    }
  },
  {
    "action": "calculate-tax",
    "status": 300,
    "response": {
      "married": "no",
      "children": "2",
      "salary": "45000",
      "tax": 3250,
      "surcharge": 370,
      "discount": 0,
      "reduction": 0,
      "rate": 0.3
    }
  },
  {
    "action": "calculate-tax",
    "status": 300,
    "response": {
      "married": "no",
      "children": "1",
      "salary": "30000",
      "tax": 1687,
      "surcharge": 0,
      "discount": 0,
      "reduction": 0,
      "rate": 0.14
    }
  }
]
"-----------list-of-simulations"
{
  "action": "list-simulations",
  "status": 500,
  "response": [
    {
      "married": "no",
      "children": "2",
      "salary": "45000",
      "tax": 3250,
      "surcharge": 370,
      "discount": 0,
      "reduction": 0,
      "rate": 0.3
    },
    {
      "married": "yes",
      "children": "2",
      "salary": "45000",
      "tax": 502,
      "surcharge": 0,
      "discount": 857,
      "reduction": 126,
      "rate": 0.14
    },
    {
      "married": "no",
      "children": "1",
      "salary": "30000",
      "tax": 1687,
      "surcharge": 0,
      "discount": 0,
      "reduction": 0,
      "rate": 0.14
    }
  ]
}
"-----------deleting simulation no. 1"
{
  "action": "delete-simulation",
  "status": 600,
  "response": [
    {
      "married": "no",
      "children": "2",
      "salary": "45000",
      "tax": 3250,
      "surcharge": 370,
      "discount": 0,
      "reduction": 0,
      "rate": 0.3
    },
    {
      "married": "no",
      "children": "1",
      "salary": "30000",
      "tax": 1687,
      "surcharge": 0,
      "discount": 0,
      "reduction": 0,
      "rate": 0.14
    }
  ]
}

6.3. Cliente HTTP 2

Image

A arquitetura do cliente HTTP 2 é a seguinte:

Image

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:

'use strict';

// classe de negócio
class Business {

  // [any]: a estrutura exata dos dados enviados pelo servidor de impostos (alíquotas, tetos, ...)
  // não está documentada aqui; por isso permanecemos deliberadamente flexíveis neste tipo
  taxAdminData: any;

  // construtor
  constructor(taxAdmindata: any) {
    // this.taxAdminData: dados da administração tributária
    this.taxAdminData = taxAdmindata;
  }

  // cálculo do imposto
  // --------------------------------------------------------------------------
  calculateTax(married: string, children: number, salary: number): any {
    // married: sim, não
    // children: número de filhos
    // salary: salário anual
    // this.taxAdminData: dados da administração tributária
    //
    // cálculo do imposto com filhos
    const result1 = this.calculateTax2(married, children, salary);
    const tax1 = result1["tax"];
    // cálculo do imposto sem os filhos
    let result2, tax2, halfShareCeiling;
    if (children !== 0) {
      result2 = this.calculateTax2(married, 0, salary);
      tax2 = result2["tax"];
      // aplicação do teto do quociente familiar
      halfShareCeiling = this.taxAdminData.halfShareQfCeiling;
      if (children < 3) {
        // HALF_SHARE_QF_CEILING euros para os 2 primeiros filhos
        tax2 = tax2 - children * halfShareCeiling;
      } else {
        // HALF_SHARE_QF_CEILING euros para os 2 primeiros filhos, o dobro para os seguintes
        tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
      }
    } else {
      // sem novo cálculo do imposto
      tax2 = tax1;
      result2 = result1;
    }
    // tomamos o maior imposto entre [tax1, tax2]
    let tax, rate, surcharge;
    if (tax1 > tax2) {
      tax = tax1;
      rate = result1["rate"];
      surcharge = result1["surcharge"];
    } else {
      surcharge = tax2 - tax1 + result2["surcharge"];
      tax = tax2;
      rate = result2["rate"];
    }
    // cálculo de um possível abatimento
    const discount = this.getDiscount(married, tax);
    tax -= discount;
    // cálculo de uma possível redução de imposto
    const reduction = this.getReduction(married, salary, children, tax);
    tax -= reduction;
    // resultado
    return {
      "tax": Math.floor(tax), "surcharge": surcharge, "discount": discount, "reduction": reduction,
      "rate": rate
    };
  }

  // --------------------------------------------------------------------------
  calculateTax2(married: string, children: number, salary: number): any {
    // married: sim, não
    // children: número de filhos
    // salary: salário anual
    // this->taxAdminData: dados da administração tributária
    // 
    // número de partes
    married = married.toLowerCase();
    let shares;
    if (married === "yes") {
      shares = children / 2 + 2;
    } else {
      shares = children / 2 + 1;
    }
    // 1 parte por filho a partir do 3º
    if (children >= 3) {
      // mais meia parte para cada filho a partir do 3º
      shares += 0.5 * (children - 2);
    }
    // renda tributável
    const taxableIncome = this.getTaxableIncome(salary);
    // acréscimo
    let surcharge = Math.floor(taxableIncome - 0.9 * salary);
    // por questões de arredondamento
    if (surcharge < 0) {
      surcharge = 0;
    }
    // quociente familiar
    const quotient = taxableIncome / shares;
    // cálculo do imposto
    const limits = this.taxAdminData.limits;
    const coeffR = this.taxAdminData.coeffR;
    const coeffN = this.taxAdminData.coeffN;
    // é colocado no final do array de limites para interromper o laço seguinte
    limits[limits.length - 1] = quotient;
    // busca da alíquota do imposto
    let i = 0;
    while (quotient > limits[i]) {
      i++;
    }
    // como colocamos quotient no final do array de limites, o laço anterior
    // não pode ultrapassar o array de limites
    // agora podemos calcular o imposto
    const tax = Math.floor(taxableIncome * coeffR[i] - shares * coeffN[i]);
    // resultado
    return { "tax": tax, "surcharge": surcharge, "rate": coeffR[i] };
  }

  // taxableIncome=annualSalary-allowance
  // a dedução tem um mínimo e um máximo
  getTaxableIncome(salary: number): number {
    // dedução de 10% do salário
    let allowance = 0.1 * salary;
    // essa dedução não pode exceder taxAdminData.getTenPercentAllowanceMax()
    if (allowance > this.taxAdminData.tenPercentAllowanceMax) {
      allowance = this.taxAdminData.tenPercentAllowanceMax;
    }
    // a dedução não pode ser inferior a taxAdminData.getTenPercentAllowanceMin()
    if (allowance < this.taxAdminData.tenPercentAllowanceMin) {
      allowance = this.taxAdminData.tenPercentAllowanceMin;
    }
    // renda tributável
    const taxableIncome = salary - allowance;
    // resultado
    return Math.floor(taxableIncome);
  }

  // calcula um possível abatimento
  getDiscount(married: string, taxes: number): number {
    // inicialmente, um abatimento nulo
    let discount = 0;
    // valor máximo do imposto para ter direito ao abatimento
    let taxCeilingForDiscount = married === "yes" ?
      this.taxAdminData.coupleTaxCeilingForDiscount :
      this.taxAdminData.singleTaxCeilingForDiscount;
    let discountCeiling;
    if (taxes < taxCeilingForDiscount) {
      // valor máximo do abatimento
      discountCeiling = married === "yes" ?
        this.taxAdminData.coupleDiscountCeiling :
        this.taxAdminData.singleDiscountCeiling;
      // abatimento teórico
      discount = discountCeiling - 0.75 * taxes;
      // o abatimento não pode exceder o valor do imposto
      if (discount > taxes) {
        discount = taxes;
      }
      // nenhum abatimento <0
      if (discount < 0) {
        discount = 0;
      }
    }
    // resultado
    return Math.ceil(discount);
  }

  // calcula uma possível redução
  getReduction(married: string, salary: number, children: number, taxes: number): number {
    // o teto de renda para ter direito à redução de 20%
    let incomeCeilingForReduction = married === "yes" ?
      this.taxAdminData.coupleIncomeCeilingForReduction :
      this.taxAdminData.singleIncomeCeilingForReduction;
    incomeCeilingForReduction += children * this.taxAdminData.halfShareReductionValue;
    if (children > 2) {
      incomeCeilingForReduction += (children - 2) * this.taxAdminData.halfShareReductionValue;
    }
    // renda tributável
    const taxableIncome = this.getTaxableIncome(salary);
    // redução
    let reduction = 0;
    if (taxableIncome < incomeCeilingForReduction) {
      // redução de 20%
      reduction = 0.2 * taxes;
    }
    // resultado
    return Math.ceil(reduction);
  }
}

// exportação da classe
export default Business;
  • 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]

Image

A classe [Dao2] implementa a camada [dao] do cliente JavaScript acima da seguinte forma:

'use strict';

// importações
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao2 {

  private axios: AxiosInstance;
  private sessionCookieName: string;
  private sessionCookie: string;

  // construtor
  constructor(axios: AxiosInstance) {
    this.axios = axios;
    // cookie de sessão
    this.sessionCookieName = "PHPSESSID";
    this.sessionCookie = '';
  }

  // inicialização da sessão
  async initSession(): Promise<any> {
    // opções da requisição HTTP [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // opções da requisição HTTP [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // corpo do POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // parâmetros da URL
      params: {
        action: 'authenticate-user'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  async getAdminData(): Promise<any> {
    // opções da requisição HTTP  [get /main.php?action=get-admindata]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'get-admindata'
      }
    };
    // execução da requisição HTTP
    const data = await this.getRemoteData(options);
    // resultado
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // para o cookie de sessão
    if (!options.headers) {
      options.headers = {} as any;
    }
    (options.headers as any).Cookie = this.sessionCookie;
    // execução da requisição HTTP
    let response: AxiosResponse;
    try {
      // requisição assíncrona
      response = await this.axios.request(options);
    } catch (error: any) {
      // o parâmetro [error] é uma instância de exceção - pode assumir várias formas
      if (error.response) {
        // a resposta do servidor está em [error.response]
        response = error.response;
      } else {
        // relançamos o erro
        throw error;
      }
    }
    // response é a resposta HTTP completa do servidor (cabeçalhos HTTP + a própria resposta)
    // recuperamos o cookie de sessão, se existir
    const setCookie = response.headers['set-cookie'];
    if (setCookie) {
      // setCookie é um array
      // procuramos o cookie de sessão nesse array
      let found = false;
      let i = 0;
      while (!found && i < setCookie.length) {
        // procuramos o cookie de sessão
        const results = RegExp('^(' + this.sessionCookieName + '.+?);').exec(setCookie[i]);
        if (results) {
          // armazenamos o cookie de sessão
          // eslint-disable-next-line require-atomic-updates
          this.sessionCookie = results[1];
          // encontramos
          found = true;
        } else {
          // próximo elemento
          i++;
        }
      }
    }
    // a resposta do servidor está em [response.data]
    return response.data;
  }
}

// exportação da classe
export default Dao2;

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:

{
    "action": "get-admindata",
    "status": 1000,
    "response": {
        "limits": [
            9964,
            27519,
            73779,
            156244,
            0,
            9964,
            27519,
            73779,
            156244,
            0
        ],
        "coeffR": [
            0,
            0.14,
            0.3,
            0.41,
            0.45,
            0,
            0.14,
            0.3,
            0.41,
            0.45
        ],
        "coeffN": [
            0,
            1394.96,
            5798,
            13913.69,
            20163.45,
            0,
            1394.96,
            5798,
            13913.69,
            20163.45
        ],
        "halfShareQfCeiling": "1551.00",
        "singleIncomeCeilingForReduction": "21037.00",
        "coupleIncomeCeilingForReduction": "42074.00",
        "halfShareReductionValue": "3797.00",
        "singleDiscountCeiling": "1196.00",
        "coupleDiscountCeiling": "1970.00",
        "coupleTaxCeilingForDiscount": "2627.00",
        "singleTaxCeilingForDiscount": "1595.00",
        "tenPercentAllowanceMax": "12502.00",
        "tenPercentAllowanceMin": "437.00"
    }
}

O conteúdo das duas tabelas do banco de dados está disponível na forma jSON.

6.3.3. O script [main2]

Image

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:

// importações
import axios from 'axios';

// importações
import Dao from './Dao2.js';
import Business from './Business.js';

// função [main] assíncrona
async function main(): Promise<void> {
  // configuração do axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost';
  // instanciação da camada [dao]
  const dao = new Dao(axios);
  // requisições HTTP
  let taxAdminData: any;
  try {
    // inicialização da sessão
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    // autenticação
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // dados do imposto
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    taxAdminData = response.response;
  } catch (error: any) {
    // registramos o erro no log
    console.log("error=", error.message);
    // fim
    return;
  }

  // instanciação da camada [business]
  const business = new Business(taxAdminData);

  // cálculos de imposto
  log("-----------calculate-tax x 3");
  const simulations: any[] = [];
  simulations.push(business.calculateTax("yes", 2, 45000));
  simulations.push(business.calculateTax("no", 2, 45000));
  simulations.push(business.calculateTax("no", 1, 30000));
  // lista de simulações
  log("-----------list-of-simulations");
  log(simulations);
  // exclusão de uma simulação
  log("-----------deleting simulation no. 1");
  simulations.splice(1, 1);
  log(simulations);
}

// log JSON
function log(object: unknown): void {
  console.log(JSON.stringify(object, null, 2));
}

// execução
main();
  • 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.
npx tsx main2.ts

Resultado da execução:

"-----------init-session"
{
  "action": "init-session",
  "status": 700,
  "response": "session started with type [json]"
}
"-----------authenticate-user"
{
  "action": "authenticate-user",
  "status": 200,
  "response": "Authentication successful [admin, admin]"
}
"-----------get-admindata"
{
  "action": "get-admindata",
  "status": 1000,
  "response": {
    "limits": [
      9964,
      27519,
      73779,
      156244,
      0,
      9964,
      27519,
      73779,
      156244,
      0
    ],
    "coeffR": [
      0,
      0.14,
      0.3,
      0.41,
      0.45,
      0,
      0.14,
      0.3,
      0.41,
      0.45
    ],
    "coeffN": [
      0,
      1394.96,
      5798,
      13913.69,
      20163.45,
      0,
      1394.96,
      5798,
      13913.69,
      20163.45
    ],
    "halfShareQfCeiling": "1551.00",
    "singleIncomeCeilingForReduction": "21037.00",
    "coupleIncomeCeilingForReduction": "42074.00",
    "halfShareReductionValue": "3797.00",
    "singleDiscountCeiling": "1196.00",
    "coupleDiscountCeiling": "1970.00",
    "coupleTaxCeilingForDiscount": "2627.00",
    "singleTaxCeilingForDiscount": "1595.00",
    "tenPercentAllowanceMax": "12502.00",
    "tenPercentAllowanceMin": "437.00"
  }
}
"-----------calculate-tax x 3"
"-----------list-of-simulations"
[
  {
    "tax": 502,
    "surcharge": 0,
    "discount": 857,
    "reduction": 126,
    "rate": 0.14
  },
  {
    "tax": 3250,
    "surcharge": 370,
    "discount": 0,
    "reduction": 0,
    "rate": 0.3
  },
  {
    "tax": 1687,
    "surcharge": 0,
    "discount": 0,
    "reduction": 0,
    "rate": 0.14
  }
]
"-----------deleting simulation no. 1"
[
  {
    "tax": 502,
    "surcharge": 0,
    "discount": 857,
    "reduction": 126,
    "rate": 0.14
  },
  {
    "tax": 1687,
    "surcharge": 0,
    "discount": 0,
    "reduction": 0,
    "rate": 0.14
  }
]

6.4. Cliente HTTP 3

Nesta seção, executamos a aplicação [HTTP client 2] em um navegador segundo a seguinte arquitetura:

Image

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]:

/* eslint-disable */

const path = require("path");
const webpack = require("webpack");

/*
 * O SplitChunksPlugin é habilitado por padrão e substituiu o
 * CommonsChunkPlugin, obsoleto. Ele identifica automaticamente os módulos que
 * devem ser separados em chunks por heurística, usando a contagem de duplicação de módulos e
 * a categoria do módulo (p. ex. node_modules). E divide os chunks…
 *
 * É seguro remover "splitChunks" da configuração gerada
 * e ele foi adicionado como exemplo educativo.
 *
 * https://webpack.js.org/plugins/split-chunks-plugin/
 *
 */

const HtmlWebpackPlugin = require("html-webpack-plugin");

/*
 * Habilitamos o HtmlWebpackPlugin para você! Ele gera uma página html
 * para você quando você compila o webpack, o que permite começar a
 * desenvolver e a prototipar mais rápido.
 *
 * https://github.com/jantimon/html-webpack-plugin
 *
 */

// [atualização TypeScript] os fontes agora estão em .ts: o webpack deve resolvê-los
// (resolve.extensions) e compilá-los com [ts-loader] em vez do
// [babel-loader] (que não entende a sintaxe TypeScript: tipos, interfaces, ...)
module.exports = {
  mode: "development",
  //entry: "./src/main3.ts",
  entry: "./src/index.ts",
  output: {
    filename: "[name].[chunkhash].js",
    path: path.resolve(__dirname, "dist")
  },

  resolve: {
    extensions: [".ts", ".js"]
  },

  plugins: [new webpack.ProgressPlugin(), new HtmlWebpackPlugin()],

  module: {
    rules: [
      {
        test: /\.ts$/,
        include: [path.resolve(__dirname, "src")],
        loader: "ts-loader"
      }
    ]
  },

  optimization: {
    splitChunks: {
      cacheGroups: {
        vendors: {
          priority: -10,
          test: /[\\/]node_modules[\\/]/
        }
      },

      chunks: "async",
      minChunks: 1,
      minSize: 30000,
      name: true
    }
  },

  devServer: {
    open: true
  }
};
  • 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:

console.log("Hello, world");

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):

{
  "name": "http-client-3",
  "version": "1.0.0",
  "description": "My webpack project",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack",
    "start": "webpack-dev-server"
  },
  "author": "serge.tahe@gmail.com",
  "license": "ISC",
  "devDependencies": {
    "@webpack-cli/init": "^0.2.2",
    "html-webpack-plugin": "^3.2.0",
    "ts-loader": "^8.4.0",
    "typescript": "^5.6.0",
    "webpack": "^4.40.2",
    "webpack-cli": "^3.3.9",
    "webpack-dev-server": "^3.8.1"
  },
  "dependencies": {
    "axios": "^1.7.0",
    "core-js": "^3.2.1",
    "qs": "^6.12.0",
    "regenerator-runtime": "^0.13.3"
  }
}
  • 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]:

1
2
3
4
5
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "build": "webpack",
    "start": "webpack-dev-server"
  },

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:

npm run build

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:

1
2
3
4
5
6
7
8
9
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Webpack App</title>
  </head>
  <body>
  <script type="text/javascript" src="main.e771aaace94e5be51a5a.js"></script></body>
</html>

Essa página, portanto, apenas encapsula o arquivo [main.hash.js] gerado pelo [webpack].

O projeto é executado pela tarefa [start]:

npm run 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:
console.log("Hello, world");

Agora, vamos alterar esse conteúdo para a seguinte linha em [index.ts]:

console.log("Hello World");

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:

Image

  • 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):

// importações
import axios from 'axios';
import "core-js/stable";
import "regenerator-runtime/runtime";

// importações
import Dao from './Dao3';
import Business from './Business';

// função [main] assíncrona
async function main(): Promise<void> {
  // configuração do axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost:3000/';
  axios.defaults.withCredentials = true;
  // instanciação da camada [dao]
  const dao = new Dao(axios);
  // requisições HTTP
  let taxAdminData: any;
  try {
    // inicialização da sessão
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    if (response.status != 700) {
      throw new Error(JSON.stringify(response.response));
    }
    // authentication
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    if (response.status != 200) {
      throw new Error(JSON.stringify(response.response));
    }
    // dados do imposto
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    if (response.status != 1000) {
      throw new Error(JSON.stringify(response.response));
    }
    taxAdminData = response.response;
  } catch (error: any) {
    // registramos o erro no log
    console.log("error=", error.message);
    // end
    return;
  }

  // instanciação da camada [business]
  const business = new Business(taxAdminData);

  // cálculos de imposto
  log("-----------calculate-tax x 3");
  const simulations: any[] = [];
  simulations.push(business.calculateTax("yes", 2, 45000));
  simulations.push(business.calculateTax("no", 2, 45000));
  simulations.push(business.calculateTax("no", 1, 30000));
  // lista de simulações
  log("-----------list-of-simulations");
  log(simulations);
  // exclusão de uma simulação
  log("-----------deleting simulation no. 1");
  simulations.splice(1, 1);
  log(simulations);
}

// log JSON
function log(object: unknown): void {
  console.log(JSON.stringify(object, null, 2));
}

// execution
main();
  • 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]:

'use strict';

// importações
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao3 {

  private axios: AxiosInstance;

  // constructor
  constructor(axios: AxiosInstance) {
    this.axios = axios;
  }

  // inicialização da sessão
  async initSession(): Promise<any> {
    // opções da requisição HTTP [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // opções da requisição HTTP [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // corpo do POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // parâmetros da URL
      params: {
        action: 'authenticate-user'
      }
    };
    // execução da requisição HTTP
    return await this.getRemoteData(options);
  }

  async getAdminData(): Promise<any> {
    // opções da requisição HTTP  [get /main.php?action=get-admindata]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // parâmetros da URL
      params: {
        action: 'get-admindata'
      }
    };
    // execução da requisição HTTP
    const data = await this.getRemoteData(options);
    // result
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // execução da requisição HTTP
    let response: AxiosResponse;
    try {
      // requisição assíncrona
      response = await this.axios.request(options);
    } catch (error: any) {
      // o parâmetro [error] é uma instância de exceção - pode assumir várias formas
      if (error.response) {
        // a resposta do servidor está em [error.response]
        response = error.response;
      } else {
        // relançamos o erro
        throw error;
      }
    }
    // response is the whole HTTP response of the server (HTTP headers + the response itself)
    // a resposta do servidor está em [response.data]
    return response.data;
  }
}

// exportação da classe
export default Dao3;

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.
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Tax application</title>
  <style>
    :root {
      --title-blue: #1976d2;
      --light-blue: #d6e9f8;
      --light-blue-border: #b6d7f0;
      --light-green: #dcedc8;
      --light-green-border: #b9d999;
      --banner-grey: #e8eaed;
      --text-grey: #333;
      --link-blue: #1a73e8;
    }

    * {
      box-sizing: border-box;
    }

    body {
      margin: 0;
      font-family: -apple-system, "Segoe UI", Arial, sans-serif;
      color: var(--text-grey);
      background: #ffffff;
    }

    #app {
      max-width: 900px;
      margin: 20px auto;
      border: 1px solid #ddd;
    }

    /* ---------- banner ---------- */
    .banner {
      display: flex;
      align-items: center;
      gap: 24px;
      background: var(--banner-grey);
      padding: 20px 30px;
    }

    .banner .logo {
      flex: none;
    }

    .banner h1 {
      margin: 0;
      font-size: 28px;
      font-weight: 400;
      color: #444;
    }

    /* ---------- page body ---------- */
    .page-body {
      display: flex;
      min-height: 320px;
    }

    .menu {
      flex: 0 0 160px;
      padding: 24px 16px;
      border-right: 1px solid #eee;
    }

    .menu a {
      display: block;
      color: var(--link-blue);
      text-decoration: none;
      margin-bottom: 14px;
      cursor: pointer;
      font-size: 14px;
    }

    .menu a:hover {
      text-decoration: underline;
    }

    .content {
      flex: 1;
      padding: 24px 30px;
    }

    .content.full-width {
      flex: 1 1 100%;
    }

    /* ---------- section title ---------- */
    .section-title {
      background: var(--light-blue);
      border: 1px solid var(--light-blue-border);
      padding: 10px 16px;
      font-size: 16px;
      margin-bottom: 20px;
    }

    /* ---------- forms ---------- */
    .field-row {
      display: flex;
      align-items: center;
      margin-bottom: 16px;
    }

    .field-row label {
      flex: 0 0 220px;
      font-size: 14px;
    }

    .field-row .field {
      display: flex;
      flex-direction: column;
    }

    .field-row input[type="text"],
    .field-row input[type="password"],
    .field-row input[type="number"] {
      padding: 6px 8px;
      border: 1px solid #bbb;
      border-radius: 3px;
      font-size: 14px;
      width: 160px;
    }

    .field-row .help {
      font-size: 11px;
      color: #888;
      margin-top: 3px;
    }

    .radios label {
      flex: none;
      font-weight: normal;
      margin-right: 12px;
    }

    button, .btn-submit {
      background: #2196f3;
      color: #fff;
      border: none;
      border-radius: 3px;
      padding: 8px 20px;
      font-size: 14px;
      cursor: pointer;
    }

    button:hover {
      background: #1976d2;
    }

    /* ---------- result / error ---------- */
    .result {
      background: var(--light-green);
      border: 1px solid var(--light-green-border);
      padding: 14px 18px;
      margin-top: 20px;
      font-size: 14px;
      line-height: 1.7;
    }

    .error {
      background: #fde8e8;
      border: 1px solid #f3b4b4;
      color: #a02020;
      padding: 12px 16px;
      margin-bottom: 16px;
      font-size: 14px;
    }

    /* ---------- table of simulations ---------- */
    table.simulations {
      border-collapse: collapse;
      width: 100%;
      font-size: 13px;
    }

    table.simulations th,
    table.simulations td {
      border: 1px solid #ddd;
      padding: 8px 10px;
      text-align: right;
    }

    table.simulations th:first-child,
    table.simulations td:first-child,
    table.simulations th:nth-child(2),
    table.simulations td:nth-child(2) {
      text-align: left;
    }

    table.simulations th {
      background: #f5f5f5;
      font-weight: 600;
    }

    table.simulations a.delete {
      color: var(--link-blue);
      cursor: pointer;
      text-decoration: none;
    }

    table.simulations a.delete:hover {
      text-decoration: underline;
    }

    .simulations-empty {
      font-size: 14px;
      color: #777;
      font-style: italic;
    }
  </style>
</head>
<body>
  <div id="app"></div>
</body>
</html>

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]:

module.exports = {
  mode: "development",
  // cliente HTML (views de autenticação / cálculo / lista de simulações)
  entry: "./src/AppHtml.ts",
  // ponto de entrada inicial do projeto (teste em console das camadas [dao]/[business]),
  // mantido para referência - você pode voltar a ele comentando a linha acima
  //entry: "./src/main3.ts",
  //entry: "./src/index.ts",
  output: {
    filename: "[name].[chunkhash].js",
    path: path.resolve(__dirname, "dist")
  },

  resolve: {
    extensions: [".ts", ".js"]
  },

  plugins: [
    new webpack.ProgressPlugin(),
    // template específico do cliente HTML (banner, estilos, <div id="app">)
    new HtmlWebpackPlugin({
      template: path.resolve(__dirname, "src/index.html")
    })
  ],
  • 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 private antes do parâmetro é um atalho que cria automaticamente um atributo root sem que seja preciso escrever this.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 error nã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 catch trata 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 authenticate como 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 business já 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:

Image

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.

Image

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).

Image

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.