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

6.1. Introdução
Este capítulo reproduz, sem alterações estruturais, as três camadas sucessivas de clientes construídas no curso de TypeScript, cada uma refinando a anterior: um primeiro cliente, CLI, em que todos os cálculos permanecem no lado do servidor; um segundo cliente, CLI, em que o cálculo passa para o lado do cliente (camada [business]); um terceiro cliente, compilado para o NAVEGADOR; e, por fim, um cliente completo, HTML, com suas próprias views. Todos os quatro se apoiam no mesmo servidor NestJS, instalado no capítulo anterior.
6.2. Cliente HTTP 1

6.2.1. A camada [dao]
6.2.2. script [dao1]
| // dao1.dart
// Porta Dao1.ts: a camada [dao] (Data Access Object) encapsula todos os
// detalhes da comunicação HTTP com o servidor de cálculo de imposto (URL,
// método, cookie de sessão) por trás de métodos de negócio simples
// (initSession, authenticateUser, calculateTax...).
import 'package:dio/dio.dart';
class Dao1 {
final Dio _dio;
final String _sessionCookieName;
String _sessionCookie = '';
// construtor - recebe a instância de Dio a ser usada, como o script TypeScript
// recebia a instância do axios como parâmetro
Dao1(this._dio) : _sessionCookieName = "connect.sid";
// inicialização da sessão
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
data: {'user': user, 'password': password},
contentType: Headers.formUrlEncodedContentType,
);
}
// cálculo do imposto
Future<dynamic> calculateTax(String married, int children, int salary) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'calculate-tax'},
data: {'married': married, 'children': children, 'salary': salary},
contentType: Headers.formUrlEncodedContentType,
);
}
// lista de simulações
Future<dynamic> listSimulations() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'list-simulations'},
);
}
// exclusão de uma simulação
Future<dynamic> deleteSimulation(int index) {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'delete-simulation', 'number': index},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Object? data,
String? contentType,
}) async {
// para o cookie de sessão
final options = Options(
method: method,
contentType: contentType,
headers: {'Cookie': _sessionCookie},
validateStatus: (_) => true,
);
// execução da requisição HTTP
final response = await _dio.request(
path,
queryParameters: queryParameters,
data: data,
options: options,
);
// recuperamos o cookie de sessão, se existir
final setCookie = response.headers['set-cookie'];
if (setCookie != null) {
for (final header in setCookie) {
final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
if (result != null) {
_sessionCookie = result.group(1)!;
break;
}
}
}
// a resposta do servidor está em [response.data]
return response.data;
}
}
|
Vamos comentar este código:
- Linha 48: A camada [dao] (Data Access Object) encapsula todos os detalhes da comunicação HTTP (URL, método, cookie de sessão) por trás de métodos de negócio simples - [initSession], [authenticateUser], [calculateTax], [listSimulations], [deleteSimulation] (linha 57).
- Linha 15: [Dao1(this._dio)] recebe a instância de [Dio] a ser usada como parâmetro do construtor, exatamente como o script TypeScript recebia a instância de [axios].
- Linha 65: [_getRemoteData] (privado, prefixo [_]) centraliza o rastreamento manual do cookie de sessão ([response.headers['set-cookie']], [RegExp] (linha 90)) já visto em dart_dio_03.dart: cada método público do DAO se apoia nesse mesmo método privado.
6.2.3. O [main1]
6.2.4. script [main1]
| // main1.dart
// Porta main1.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao1.dart';
Future<void> main() async {
// configuração do Dio - baseUrl/timeout globais, como axios.defaults em
// do TypeScript
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// instanciação da camada [dao]
final dao = Dao1(dio);
// uso da camada [dao]
try {
// inicialização da sessão
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// autenticação
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// cálculos de imposto - Future.wait é o equivalente Dart de Promise.all
// (já visto em async_05.dart)
log("-----------calculate-tax x 3");
response = await Future.wait([
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) {
// registramos o erro no log
print("error=$error");
}
}
// log JSON
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Vamos comentar este código:
- linha 16: [final dao = Dao1(dio);]: a camada [dao] é instanciada uma única vez e depois reutilizada em toda a sequência de chamadas (init-session, autenticação, cálculos, listagem, exclusão).
- Linhas 30–31: [Future.wait([dao.calculateTax(...), ...])]: os três cálculos de imposto são lançados EM PARALELO, o equivalente em Dart de [Promise.all], já visto em async_05.dart.
- Linhas 52–53: [JsonEncoder.withIndent(' ').convert(object)]: a função utilitária [log] reproduz a exibição indentada de [JSON.stringify(x, null, 2)].
O resultado da execução é o seguinte:
| "-----------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": "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": "yes",
"children": 2,
"salary": 45000,
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
}
]
}
|
6.3. Cliente HTTP 2

Este segundo cliente move o CÁLCULO do imposto do servidor para o cliente: o servidor agora fornece os dados fiscais brutos (alíquotas, faixas etc.) uma única vez por meio de [get-admindata], e a camada [business] passa a realizar os cálculos.
6.3.1. O [Business]
6.3.2. script [business]
| // business.dart
// Porta Business.ts: o cálculo do imposto, feito inteiramente no lado do cliente
// (no navegador em TypeScript, aqui no programa Dart), a partir
// dos dados tributários brutos obtidos uma única vez do servidor por meio de
// [Dao2.getAdminData] (veja dao2.dart).
class Business {
// [dynamic]: a estrutura exata dos dados enviados pelo servidor de
// imposto (alíquotas, tetos...) não está documentada aqui; como em
// TypeScript, mantemos deliberadamente a flexibilidade nesse tipo
final Map<String, dynamic> taxAdminData;
Business(this.taxAdminData);
// cálculo do imposto
// --------------------------------------------------------------------------
// married: sim, não
// children: número de filhos
// salary: salário anual
Map<String, dynamic> calculateTax(String married, int children, num salary) {
// cálculo do imposto com filhos
final result1 = _calculateTax2(married, children, salary);
final tax1 = result1['tax'] as num;
// cálculo do imposto sem os filhos
Map<String, dynamic> result2;
num tax2;
num halfShareCeiling;
if (children != 0) {
result2 = _calculateTax2(married, 0, salary);
tax2 = result2['tax'] as num;
// aplicação do teto do quociente familiar
halfShareCeiling = taxAdminData['halfShareQfCeiling'] as num;
if (children < 3) {
// halfShareCeiling para os 2 primeiros filhos
tax2 = tax2 - children * halfShareCeiling;
} else {
// halfShareCeiling para os 2 primeiros filhos, dobrado para os seguintes
tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
}
} else {
// sem recálculo do imposto
tax2 = tax1;
result2 = result1;
}
// pegamos o maior imposto entre [tax1, tax2]
num tax;
num rate;
num surcharge;
if (tax1 > tax2) {
tax = tax1;
rate = result1['rate'] as num;
surcharge = result1['surcharge'] as num;
} else {
surcharge = tax2 - tax1 + (result2['surcharge'] as num);
tax = tax2;
rate = result2['rate'] as num;
}
// cálculo de um possível desconto
final discount = _getDiscount(married, tax);
tax -= discount;
// cálculo de uma possível redução de imposto
final reduction = _getReduction(married, salary, children, tax);
tax -= reduction;
// resultado
return {
'tax': tax.floor(),
'surcharge': surcharge,
'discount': discount,
'reduction': reduction,
'rate': rate,
};
}
// --------------------------------------------------------------------------
Map<String, dynamic> _calculateTax2(String married, int children, num salary) {
// número de partes
married = married.toLowerCase();
num 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
final taxableIncome = _getTaxableIncome(salary);
// sobretaxa
num surcharge = (taxableIncome - 0.9 * salary).floor();
// por questões de arredondamento
if (surcharge < 0) {
surcharge = 0;
}
// quociente familiar
final quotient = taxableIncome / shares;
// cálculo do imposto
final List<num> limits = List<num>.from(taxAdminData['limits'] as List);
final List<num> coeffR = List<num>.from(taxAdminData['coeffR'] as List);
final List<num> coeffN = List<num>.from(taxAdminData['coeffN'] as List);
// é colocado no final da lista [limits] para parar o laço seguinte
limits[limits.length - 1] = quotient;
// procurando a alíquota do imposto
var i = 0;
while (quotient > limits[i]) {
i++;
}
// como colocamos quotient no final de limits, o laço anterior
// não pode ultrapassar a lista limits
// agora podemos calcular o imposto
final tax = (taxableIncome * coeffR[i] - shares * coeffN[i]).floor();
// resultado
return {'tax': tax, 'surcharge': surcharge, 'rate': coeffR[i]};
}
// taxableIncome = annualSalary - allowance (a dedução tem um mínimo e um máximo)
num _getTaxableIncome(num salary) {
// dedução de 10% do salário
num allowance = 0.1 * salary;
// esta dedução não pode exceder tenPercentAllowanceMax
final allowanceMax = taxAdminData['tenPercentAllowanceMax'] as num;
if (allowance > allowanceMax) {
allowance = allowanceMax;
}
// a dedução não pode ser inferior a tenPercentAllowanceMin
final allowanceMin = taxAdminData['tenPercentAllowanceMin'] as num;
if (allowance < allowanceMin) {
allowance = allowanceMin;
}
// renda tributável
final taxableIncome = salary - allowance;
return taxableIncome.floor();
}
// calcula um possível desconto
num _getDiscount(String married, num taxes) {
// inicialmente, um desconto zero
num discount = 0;
// valor máximo do imposto para ter direito ao desconto
final taxCeilingForDiscount = married == "yes"
? taxAdminData['coupleTaxCeilingForDiscount'] as num
: taxAdminData['singleTaxCeilingForDiscount'] as num;
if (taxes < taxCeilingForDiscount) {
// valor máximo do desconto
final discountCeiling = married == "yes"
? taxAdminData['coupleDiscountCeiling'] as num
: taxAdminData['singleDiscountCeiling'] as num;
// desconto teórico
discount = discountCeiling - 0.75 * taxes;
// o desconto não pode exceder o valor do imposto
if (discount > taxes) {
discount = taxes;
}
// nenhum desconto < 0
if (discount < 0) {
discount = 0;
}
}
// resultado - ceil() é o equivalente Dart de Math.ceil()
return discount.ceil();
}
// calcula uma possível redução
num _getReduction(String married, num salary, int children, num taxes) {
// o teto de renda para ter direito à redução de 20%
num incomeCeilingForReduction = married == "yes"
? taxAdminData['coupleIncomeCeilingForReduction'] as num
: taxAdminData['singleIncomeCeilingForReduction'] as num;
final halfShareReductionValue = taxAdminData['halfShareReductionValue'] as num;
incomeCeilingForReduction += children * halfShareReductionValue;
if (children > 2) {
incomeCeilingForReduction += (children - 2) * halfShareReductionValue;
}
// renda tributável
final taxableIncome = _getTaxableIncome(salary);
// redução
num reduction = 0;
if (taxableIncome < incomeCeilingForReduction) {
// redução de 20%
reduction = 0.2 * taxes;
}
return reduction.ceil();
}
}
|
Vamos analisar este código:
- linha 12: [Business(this.taxAdminData)]: o construtor recebe os dados fiscais brutos recuperados pelo DAO uma única vez —nenhuma outra chamada de rede é necessária depois disso para calcular um imposto.
- linha 19: [Map<String, dynamic> calculateTax(String married, int children, num salary)]: uma conversão fiel, linha por linha, do algoritmo TypeScript —mesmas etapas ([_calculateTax2], [_getTaxableIncome], [_getDiscount], [_getReduction]), mesma lógica para limitar o quociente familiar.
- [.floor()]/[.ceil()] (métodos de [num]) substituem [Math.floor(...)]/[Math.ceil(...)]: em Dart, são métodos de instância do próprio número, e não métodos estáticos de uma classe utilitária.
- As CHAVES do [Map] retornado ([tax], [surcharge], [discount], [reduction]...) têm os mesmos nomes ASCII simples que os IDENTIFICADORES Dart (nomes de variáveis e parâmetros) —uma string pode conter acentos em Dart, mas um identificador não (veja simulation.dart, mais adiante neste capítulo).
6.3.3. O [Dao2]
6.3.4. script [dao2]
| // dao2.dart
// Porta Dao2.ts: idêntico a dao1.dart para initSession e
// authenticateUser, mas expõe [getAdminData] em vez de
// [calculateTax]/[listSimulations]/[deleteSimulation] - o cálculo e
// a lista de simulações agora são tratados no lado do CLIENTE pela
// camada [business] (veja business.dart), o servidor servindo apenas para fornecer os
// dados tributários brutos (alíquotas, tetos...).
import 'package:dio/dio.dart';
class Dao2 {
final Dio _dio;
final String _sessionCookieName;
String _sessionCookie = '';
Dao2(this._dio) : _sessionCookieName = "connect.sid";
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
data: {'user': user, 'password': password},
contentType: Headers.formUrlEncodedContentType,
);
}
Future<dynamic> getAdminData() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'get-admindata'},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Object? data,
String? contentType,
}) async {
final options = Options(
method: method,
contentType: contentType,
headers: {'Cookie': _sessionCookie},
validateStatus: (_) => true,
);
final response = await _dio.request(
path,
queryParameters: queryParameters,
data: data,
options: options,
);
final setCookie = response.headers['set-cookie'];
if (setCookie != null) {
for (final header in setCookie) {
final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
if (result != null) {
_sessionCookie = result.group(1)!;
break;
}
}
}
return response.data;
}
}
|
Vamos comentar este código:
- linha 4: Idêntico a [Dao1] para [initSession] e [authenticateUser], mas expõe [getAdminData] em vez de [calculateTax]/[listSimulations] (linha 4)/[deleteSimulation] (linha 4): essas três operações agora são tratadas no lado do CLIENTE pela camada [business] que acabamos de apresentar.
6.3.5. O [main2]
6.3.6. script [main2]
| // main2.dart
// Porta main2.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao2.dart';
import 'business.dart';
Future<void> main() async {
// configuração do Dio
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// instanciação da camada [dao]
final dao = Dao2(dio);
// requisições HTTP
Map<String, dynamic> taxAdminData;
try {
// inicialização da sessão
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// autenticação
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// dados tributários
log("-----------get-admindata");
response = await dao.getAdminData();
log(response);
taxAdminData = response['response'] as Map<String, dynamic>;
} catch (error) {
// registramos o erro no log
print("error=$error");
// fim
return;
}
// instanciação da camada [business]
final business = Business(taxAdminData);
// cálculos de imposto
log("-----------calculate-tax x 3");
final List<Map<String, dynamic>> simulations = [];
simulations.add(business.calculateTax("yes", 2, 45000));
simulations.add(business.calculateTax("no", 2, 45000));
simulations.add(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.removeAt(1);
log(simulations);
}
// log JSON
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Vamos comentar este código:
- linha 41: [final business = Business(taxAdminData);]: a camada [business] é instanciada apenas UMA VEZ, imediatamente após a recuperação dos dados fiscais do servidor.
- [simulations.add(business.calculateTax(...));]: os cálculos de imposto não envolvem mais NENHUMA chamada de rede —ao contrário de main1.dart, em que cada cálculo era uma requisição HTTP separada.
O resultado da execução é o seguinte:
| "-----------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
],
"coeffR": [
0,
0.14,
0.3,
0.41,
0.45
],
"coeffN": [
0,
1394.96,
5798,
13913.69,
20163.45
],
"halfShareQfCeiling": 1551,
"singleIncomeCeilingForReduction": 21037,
"coupleIncomeCeilingForReduction": 42074,
"halfShareReductionValue": 3797,
"singleDiscountCeiling": 1196,
"coupleDiscountCeiling": 1970,
"coupleTaxCeilingForDiscount": 2627,
"singleTaxCeilingForDiscount": 1595,
"tenPercentAllowanceMax": 12502,
"tenPercentAllowanceMin": 437
}
}
"-----------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

6.4.1. Evolução das ferramentas desde 2019
Este terceiro cliente usa o mesmo par [dao]/[business] do cliente HTTP 2, mas é COMPILADO PARA O NAVEGADOR em vez de ser executado pela linha de comando. Assim como no TypeScript, essa build exige webpack e babel, além de polyfills ([core-js/stable], [regenerator-runtime/runtime]) para que o código moderno funcione em navegadores antigos. No lado do Dart, o SDK fornece seu próprio compilador web ([dart compile js]): não são necessários polyfills; [Future]/[async]/[await], records, patterns etc. são compilados diretamente para o JavaScript equivalente, seja qual for o alvo.
6.4.2. Compilação e execução do projeto
A partir da pasta [http client 3]:
O servidor de desenvolvimento [webdev serve] não é fornecido pelo SDK do Dart: o pacote [webdev] deve primeiro ser instalado uma vez, globalmente, com [dart pub global activate webdev].
Esse comando instala o executável [webdev] no cache global do pub, uma pasta que não é adicionada automaticamente ao PATH do Windows. Para adicioná-la de uma vez por todas (para o usuário atual), abra um terminal PowerShell e execute:
| [Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:LOCALAPPDATA\Pub\Cache\bin", "User")
|
Em seguida, é preciso fechar e reabrir o terminal (ou o VSCode) para que o novo PATH tenha efeito. Depois, ainda na pasta [http client 3]:
| dart pub get
webdev serve
|
Em desenvolvimento, [webdev serve] inicia um servidor que recompila automaticamente a cada alteração (hot reload): o terminal exibe a URL a ser aberta em um navegador (padrão: http://localhost:8080). Para uma build de produção, o comando [dart compile js web/main.dart -o web/main.dart.js] continua disponível: a página [web/index.html] carrega então [main.dart.js] para testar o resultado —o mesmo conceito do ponto de entrada mínimo [src/index.ts] no curso de TypeScript.
6.4.3. O script [main3]
6.4.4. script [main3]
| // main3.dart
// Porta main3.ts.
//
// [AVISO, diferença fundamental com o TypeScript] main3.ts precisava de
// dois polyfills (core-js/stable, regenerator-runtime) para que
// async/await e recursos recentes do JavaScript funcionem em
// navegadores antigos, depois de transpilados por babel/webpack. O
// compilador Dart para a web (`dart compile js`) NÃO precisa de nenhum
// polyfill desse tipo: Future/async/await, Records, patterns...
// são compilados diretamente para JavaScript ou WebAssembly equivalente,
// seja qual for o alvo - uma vantagem direta de compilar
// a partir de uma linguagem e de ferramentas unificadas, em vez de transpilar
// JavaScript "moderno" para JavaScript "antigo".
import 'dart:convert';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
Future<void> main() async {
// cliente HTTP específico do navegador, com withCredentials=true -
// o equivalente Dart de "axios.defaults.withCredentials = true"
final client = BrowserClient()..withCredentials = true;
final dao = Dao3(client, 'http://localhost:3000');
Map<String, dynamic> taxAdminData;
try {
log("-----------init-session");
Map<String, dynamic> response = await dao.initSession();
log(response);
if (response['status'] != 700) {
throw Exception(jsonEncode(response['response']));
}
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
if (response['status'] != 200) {
throw Exception(jsonEncode(response['response']));
}
log("-----------get-admindata");
response = await dao.getAdminData();
log(response);
if (response['status'] != 1000) {
throw Exception(jsonEncode(response['response']));
}
taxAdminData = response['response'] as Map<String, dynamic>;
} catch (error) {
print("error=$error");
return;
} finally {
client.close();
}
// instanciação da camada [business]
final business = Business(taxAdminData);
log("-----------calculate-tax x 3");
final List<Map<String, dynamic>> simulations = [];
simulations.add(business.calculateTax("yes", 2, 45000));
simulations.add(business.calculateTax("no", 2, 45000));
simulations.add(business.calculateTax("no", 1, 30000));
log("-----------list-of-simulations");
log(simulations);
log("-----------deleting simulation no. 1");
simulations.removeAt(1);
log(simulations);
}
// log JSON
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Vamos comentar este código:
- linha 22: [final client = BrowserClient()..withCredentials = true;]: [BrowserClient] ([package:http/browser_client.dart]) só existe quando o código é compilado para a web; sua opção [withCredentials] é o equivalente em Dart de [axios.defaults.withCredentials = true] —o NAVEGADOR passa então a cuidar sozinho do cookie de sessão.
- O compilador web do Dart não exige NENHUM polyfill (ao contrário de main3.ts): [Future]/[async]/[await] e os recursos recentes da linguagem são compilados diretamente —um benefício direto de partir de uma linguagem e de um conjunto de ferramentas unificados, em vez de transpilar de JavaScript moderno para JavaScript legado.
6.4.5. O [Dao3]
6.4.6. script [dao3]
| // dao3.dart
// Porta tax client/http client 3/src/Dao3.ts.
//
// Diferença com dao2.dart: este arquivo se destina a ser compilado para o
// NAVEGADOR (com `dart compile js`, veja o README desta pasta), e não
// executado na CLI com `dart run`. Em um navegador, o COOKIE DE SESSÃO
// é tratado automaticamente pelo próprio navegador (como para qualquer
// página web) assim que seu envio é permitido - portanto não há mais
// necessidade do controle MANUAL de cookies feito à mão em dao1.dart/dao2.dart
// (exatamente o raciocínio, já presente, que permitiu a Dao3.ts
// remover todo o código de tratamento de cookies de Dao2.ts).
//
// [correspondência com o TypeScript] "axios.defaults.withCredentials = true"
// (definido em main3.dart, e não aqui) corresponde, do lado do pacote [http] do Dart, à
// opção [withCredentials] do cliente específico para web,
// [BrowserClient] (package:http/browser_client.dart) - uma classe que
// existe SOMENTE quando o código é compilado para a web, ao contrário de
// http.Client, que funciona em qualquer lugar.
import 'dart:convert';
import 'package:http/http.dart' as http;
class Dao3 {
final http.Client _client;
final String _baseUrl;
Dao3(this._client, this._baseUrl);
Future<dynamic> initSession() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'init-session', 'type': 'json'},
);
}
Future<dynamic> authenticateUser(String user, String password) {
return _getRemoteData(
'main.php',
method: 'POST',
queryParameters: {'action': 'authenticate-user'},
body: {'user': user, 'password': password},
);
}
Future<dynamic> getAdminData() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'get-admindata'},
);
}
Future<dynamic> _getRemoteData(
String path, {
required String method,
Map<String, dynamic>? queryParameters,
Map<String, String>? body,
}) async {
final uri = Uri.parse('$_baseUrl/$path').replace(
queryParameters: queryParameters?.map((k, v) => MapEntry(k, '$v')),
);
final http.Response response;
if (method == 'POST') {
response = await _client.post(uri, body: body);
} else {
response = await _client.get(uri);
}
// [diferença com o cliente CLI] nenhuma leitura manual do cabeçalho set-cookie
// aqui: em um navegador, response.headers nem sequer o expõe
// (cabeçalho protegido pelo navegador, invisível para o
// código JavaScript/Dart, justamente porque já é tratado por ele mesmo)
return jsonDecode(response.body);
}
}
|
Vamos comentar este código:
- NÃO há mais rastreamento manual do cookie de sessão (ao contrário de [Dao1]/[Dao2]): em um navegador, o cookie de sessão é gerenciado automaticamente pelo próprio navegador, desde que o envio de cookies seja permitido ([withCredentials], definido em main3.dart).
- [response.headers] nem sequer expõe mais o cabeçalho [set-cookie] em um navegador: um cabeçalho protegido, invisível ao código JavaScript/Dart do lado do cliente, justamente porque já é gerenciado por conta própria.
6.4.7. Compilação e execução
Veja a seção [Compiling and Running the Project] acima: o mesmo comando [dart compile js] compila [web/main.dart], que delega a [main3.dart].
Inicie o servidor de desenvolvimento para executar a aplicação web do cliente Http3:
| PS C:\Data\st-2026\dev\dart-sept-2026-scripts\dart-fundamentals\tax-client\dart-fundamentals\tax client\http client 3> webdev serve
[INFO] Serving `web` on http://127.0.0.1:8080
[INFO] ------------------------------------------------------------------------------------
[INFO] Injected debugging metadata for entrypoint at http://127.0.0.1:8080/main.dart.bootstr
[INFO] Injected debugging metadata for entrypoint at http://localhost:8080/main.dart.bootstrap.js
|
O resultado da execução é o seguinte:

- Em [1], abra um navegador e solicite a URL [http://localhost:8080];
- em [2], o texto exibido pela página solicitada;
- em [3], o resultado da execução pode ser encontrado no console do navegador (F12 e, em seguida, a opção Console). Obtemos o mesmo resultado de antes, mas desta vez em um navegador;
6.5. Cliente HTML

6.5.1. Arquitetura da solução
Este quarto e último cliente acrescenta uma verdadeira interface HTML sobre o cliente HTTP 3: as camadas [dao] ([Dao3]) e [business] ([Business]) são REUTILIZADAS SEM MODIFICAÇÃO, e duas novas camadas são acrescentadas —VIEWS (construção do DOM) e CONTROLLER (orquestração). O projeto é organizado em duas pastas, [web/] (ponto de entrada, HTML, CSS) e [lib/] (código compartilhado), seguindo a convenção de um projeto web Dart padrão —veja o README.md desta pasta para detalhes sobre essa convenção.
6.5.2. O template HTML: o arquivo [web/index.html]
Copiado exatamente de [src/index.html] (as mesmas classes CSS: [banner], [menu], [content], [section-title], [field-row], [result], [error], [simulations]...), com uma pequena diferença: o script carregado é [main.dart.js] (um nome FIXO definido pela ferramenta web do Dart), enquanto o [index.html] de Views.ts carregava um bundle do Webpack com nome HASHEADO ([main.a44f6e1c12ab338daedc.js]).
6.5.3. A configuração [webpack.config.js] modificada
Não é necessário nenhum equivalente no lado do Dart: nenhum arquivo de configuração de bundler precisa ser escrito. [web/main.dart], simplesmente por sua POSIÇÃO na árvore de diretórios (diretamente em [web/]), desempenha o papel que a linha [entry: './src/main3.ts'] desempenhava para o [webpack.config.js] —uma convenção de nomes e de localização substitui todo um arquivo de configuração.
6.5.4. As camadas [dao] e [business]: dois arquivos reutilizados sem modificação
[lib/dao3.dart] e [lib/business.dart] são cópias EXATAS dos arquivos de mesmo nome do cliente HTTP 3 - a mesma reutilização, sem nenhuma modificação, feita por Views.ts e AppHtml.ts sobre [Dao3.ts] e [Business.ts].
6.5.5. A camada [views]: o [Views.ts]
6.5.6. scripts [simulation, views]
A camada de views se apoia em TRÊS arquivos: simulation.dart (os dados exibidos), views.dart (a construção do DOM) e app_html.dart (o controller, discutido na próxima seção). Comecemos por simulation.dart:
| // simulation.dart
// O resultado de um cálculo de imposto, como retornado por business.dart,
// completado com os parâmetros informados. Porta a interface [Simulation] de Views.ts.
//
// [NOVO, Dart 3] aqui usamos um RECORD nomeado (veja
// dart-fundamentals/dart3/dart3_01_records.dart) em vez de uma classe: um
// simples alias de tipo [typedef], sem construtor nem arquivo separado a
// escrever, para dados que são apenas um "saco" simples de campos, sem comportamento
// associado - exatamente o espírito da interface TypeScript
// original.
//
// [NOTA sobre nomes de campos] ao contrário de TypeScript/JavaScript, em que
// um identificador pode conter letras acentuadas (usadas em todo o
// curso original em francês), o Dart restringe os
// identificadores a letras ASCII: acentos só são possíveis em
// STRINGS, nunca em um nome de
// variável, campo, classe ou record. De todo modo, este curso
// usa nomes ASCII simples em inglês em todo lugar (married, tax, discount...):
// os campos do record abaixo têm os mesmos nomes que as chaves do Map de
// business.dart.
typedef Simulation = ({
String married,
int children,
num salary,
num tax,
num surcharge,
num discount,
num reduction,
num rate,
});
|
Vamos analisar este código:
- linhas 21–24: [typedef Simulation = ({String married, int children, num salary, ...});]: enquanto Views.ts declarava uma INTERFACE [Simulation], este arquivo usa um record NOMEADO do Dart 3 (veja dart3_01_records.dart) —um simples alias de tipo, sem construtor nem arquivo separado, para dados puramente descritivos.
- Os nomes dos campos são ASCII simples ([married], [tax], [discount]...): os IDENTIFICADORES do Dart são restritos a letras ASCII, ao contrário do TypeScript/JavaScript, em que nomes acentuados como [marié]/[impôt] (usados no curso original em francês) são nomes de campo válidos.
[lib/views.dart], composto por DOM e [package:web]:
| // views.dart
// Porta Views.ts: construção das views (DOM) da aplicação - view de
// autenticação, view de cálculo de imposto, view de 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 a funções de callback fornecidas pelo
// controller (veja app_html.dart).
//
// [escolha técnica] aqui usamos [package:web] (pub.dev/packages/web),
// o substituto moderno do antigo dart:html: ele expõe uma API de DOM muito
// próxima do DOM padrão usado por Views.ts (document.createElement,
// .textContent, .addEventListener...). Uma diferença superficial a
// conhecer: um manipulador de eventos Dart (uma função simples) deve
// ser convertido em uma função JavaScript com [.toJS] (extensão de
// dart:js_interop) antes de ser passado a [addEventListener] - a "ponte"
// entre o mundo Dart e o mundo JavaScript, explicitada, onde
// o TypeScript não precisa de conversão (tudo ali já é
// JavaScript).
import 'dart:js_interop';
import 'package:web/web.dart' as web;
import 'simulation.dart';
// uma decoração genérica (não a foto do servidor PHP original)
const String _logoSvg = '''
<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>''';
// callbacks da view de [autenticação] - [diferença com o TypeScript]
// uma interface de callbacks do TypeScript se traduz naturalmente em um
// RECORD de funções em Dart (veja simulation.dart): mais leve que uma
// classe, para um simples grupo de funções
typedef AuthenticationCallbacks = ({void Function(String user, String password) onSubmit});
typedef CalculationCallbacks = ({
void Function(String married, int children, int salary) onSubmit,
void Function() onList,
void Function() onEndSession,
});
typedef ListCallbacks = ({
void Function(int number) onDelete,
void Function() onCalculation,
void Function() onEndSession,
});
class Views {
final web.HTMLElement root;
late web.HTMLDivElement _banner;
late web.HTMLDivElement _menu;
late web.HTMLDivElement _content;
// constrói a estrutura fixa da página (banner + área de menu/conteúdo)
// dentro do elemento [root]
Views(this.root) {
// [AVISO] ao contrário das propriedades comuns do DOM (textContent,
// value...), o setter [innerHTML] de package:web espera um [JSAny], não
// uma [String] Dart pura - uma peculiaridade de sua geração ligada ao
// atributo WebIDL [LegacyNullToEmptyString] do DOM padrão: portanto
// sempre devemos converter com [.toJS].
root.innerHTML = ''.toJS;
_banner = _div()..className = 'banner';
final logo = _div()..className = 'logo';
logo.innerHTML = _logoSvg.toJS;
final title = web.document.createElement('h1') as web.HTMLHeadingElement;
title.textContent = 'Calculate your tax';
_banner
..appendChild(logo)
..appendChild(title);
final body = _div()..className = 'page-body';
_menu = _div()..className = 'menu';
_content = _div()..className = 'content';
body
..appendChild(_menu)
..appendChild(_content);
root
..appendChild(_banner)
..appendChild(body);
}
// --------------------------------------------------------------------
// ferramentas de construção do DOM
// --------------------------------------------------------------------
web.HTMLDivElement _div() => web.document.createElement('div') as web.HTMLDivElement;
void _clearMenu() {
_menu.innerHTML = ''.toJS;
_menu.style.display = 'none';
_content.classList.add('full-width');
}
web.HTMLAnchorElement _menuLink(String text, void Function() onClick) {
final a = web.document.createElement('a') as web.HTMLAnchorElement;
a.textContent = text;
a.addEventListener('click', ((web.Event event) => onClick()).toJS);
return a;
}
void _showMenu(List<web.HTMLAnchorElement> links) {
_menu.innerHTML = ''.toJS;
_menu.style.display = '';
_content.classList.remove('full-width');
for (final link in links) {
_menu.appendChild(link);
}
}
web.HTMLElement? _errorBanner(String? message) {
if (message == null) return null;
final div = _div()..className = 'error';
div.textContent = message;
return div;
}
// uma linha de formulário [rótulo + campo texto/senha/número]
(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(
String labelText,
String type,
String initialValue, {
String? help,
}) {
final row = _div()..className = 'field-row';
final label = web.document.createElement('label') as web.HTMLLabelElement;
label.textContent = labelText;
final field = _div()..className = 'field';
final input = web.document.createElement('input') as web.HTMLInputElement;
input.type = type;
input.value = initialValue;
if (type == 'number') {
input.min = '0';
}
field.appendChild(input);
if (help != null) {
final div = _div()..className = 'help';
div.textContent = help;
field.appendChild(div);
}
row
..appendChild(label)
..appendChild(field);
return (row, input);
}
// --------------------------------------------------------------------
// view de [autenticação]
// --------------------------------------------------------------------
void authenticationView(String? error, AuthenticationCallbacks callbacks) {
_clearMenu();
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'Please authenticate';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
final userField = _fieldRow("Username", 'text', 'admin');
final passwordField = _fieldRow('Password', 'password', '');
_content
..appendChild(userField.$1)
..appendChild(passwordField.$1);
final button = web.document.createElement('button') as web.HTMLButtonElement;
button.textContent = 'Submit';
button.addEventListener(
'click',
((web.Event event) {
callbacks.onSubmit(userField.$2.value.trim(), passwordField.$2.value);
}).toJS,
);
_content.appendChild(button);
}
// --------------------------------------------------------------------
// view de [cálculo de imposto]
// --------------------------------------------------------------------
void calculationView(Simulation? result, String? error, CalculationCallbacks callbacks) {
_showMenu([
_menuLink('List of simulations', callbacks.onList),
_menuLink('End of session', callbacks.onEndSession),
]);
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'Fill in the form below and then submit it';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
// linha dos radios de [married]
final marriedRow = _div()..className = 'field-row';
final marriedLabel = web.document.createElement('label') as web.HTMLLabelElement;
marriedLabel.textContent = 'Are you married or in a civil partnership?';
final marriedField = _div()..className = 'field radios';
final radioYes = web.document.createElement('input') as web.HTMLInputElement;
radioYes.type = 'radio';
radioYes.name = 'married';
radioYes.value = 'yes';
radioYes.checked = true;
final labelYes = web.document.createElement('label') as web.HTMLLabelElement;
labelYes.appendChild(radioYes);
labelYes.appendChild(web.document.createTextNode(' Yes'));
final radioNo = web.document.createElement('input') as web.HTMLInputElement;
radioNo.type = 'radio';
radioNo.name = 'married';
radioNo.value = 'no';
final labelNo = web.document.createElement('label') as web.HTMLLabelElement;
labelNo.appendChild(radioNo);
labelNo.appendChild(web.document.createTextNode(' No'));
marriedField
..appendChild(labelYes)
..appendChild(labelNo);
marriedRow
..appendChild(marriedLabel)
..appendChild(marriedField);
_content.appendChild(marriedRow);
final childrenField = _fieldRow("Number of dependent children", 'number', '0');
_content.appendChild(childrenField.$1);
final salaryField = _fieldRow(
'Annual salary',
'number',
'',
help: "Round down to the nearest euro",
);
_content.appendChild(salaryField.$1);
final button = web.document.createElement('button') as web.HTMLButtonElement;
button.textContent = 'Submit';
button.addEventListener(
'click',
((web.Event event) {
final married = radioYes.checked ? 'yes' : 'no';
final children = int.tryParse(childrenField.$2.value) ?? 0;
final salary = int.tryParse(salaryField.$2.value) ?? 0;
callbacks.onSubmit(married, children, salary);
}).toJS,
);
_content.appendChild(button);
// resultado da última simulação (caixa verde), se houver
if (result != null) {
final box = _div()..className = 'result';
final ratePercent = (result.rate * 100).round();
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 %")
.toJS;
_content.appendChild(box);
}
}
// --------------------------------------------------------------------
// view de [lista de simulações]
// --------------------------------------------------------------------
void listView(List<Simulation> simulations, String? error, ListCallbacks callbacks) {
_showMenu([
_menuLink("Tax calculation", callbacks.onCalculation),
_menuLink('End of session', callbacks.onEndSession),
]);
_content.innerHTML = ''.toJS;
final title = _div()
..className = 'section-title'
..textContent = 'List of your simulations';
_content.appendChild(title);
final banner = _errorBanner(error);
if (banner != null) _content.appendChild(banner);
if (simulations.isEmpty) {
final empty = _div()
..className = 'simulations-empty'
..textContent = 'No simulation recorded.';
_content.appendChild(empty);
return;
}
final table = web.document.createElement('table') as web.HTMLTableElement;
table.className = 'simulations';
final thead = web.document.createElement('thead') as web.HTMLTableSectionElement;
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>")
.toJS;
table.appendChild(thead);
final tbody = web.document.createElement('tbody') as web.HTMLTableSectionElement;
for (var number = 0; number < simulations.length; number++) {
final simulation = simulations[number];
final tr = web.document.createElement('tr') as web.HTMLTableRowElement;
final ratePercent = (simulation.rate * 100).round();
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>")
.toJS;
final tdDelete = web.document.createElement('td') as web.HTMLTableCellElement;
final deleteLink = web.document.createElement('a') as web.HTMLAnchorElement;
deleteLink.className = 'delete';
deleteLink.textContent = 'Delete';
deleteLink.addEventListener(
'click',
((web.Event event) => callbacks.onDelete(number)).toJS,
);
tdDelete.appendChild(deleteLink);
tr.appendChild(tdDelete);
tbody.appendChild(tr);
}
table.appendChild(tbody);
_content.appendChild(table);
}
}
|
Vamos analisar este código:
- linha 19: [import 'package:web/web.dart' as web;]: o substituto moderno do antigo [dart:html], com uma API e um DOM muito semelhantes ao DOM padrão usado por Views.ts ([document.createElement], [.textContent], [.addEventListener]...).
- Linhas 44–45: [typedef CalculationCallbacks = ({void Function(...) onSubmit, ...});]: uma interface de callbacks do TypeScript se traduz naturalmente em um RECORD DE FUNÇÕES em Dart 3 —mais leve que uma classe para um simples grupo de funções.
- Linha 108: [a.addEventListener('click', ((web.Event event) { ... }).toJS);]: um manipulador de eventos Dart (uma simples função) deve ser convertido em função JavaScript usando [.toJS] (uma extensão de [dart:js_interop]) antes de ser passado a [addEventListener] - a “ponte” entre o mundo Dart e o mundo JavaScript é explicitada, enquanto o TypeScript não exige nenhuma conversão.
- linha 141: [input.value = initialValue;], [title.textContent = '...';] (linha 76): a maioria das propriedades do tipo string continua sendo simples strings Dart, sem necessidade de conversão. [innerHTML] é a EXCEÇÃO: [dart analyze] sinaliza isso se uma [String] for atribuída diretamente a ele —seu setter espera um [JSAny] (uma peculiaridade de sua geração, relacionada ao atributo WebIDL [LegacyNullToEmptyString] do DOM padrão)—daí [root.innerHTML = ''.toJS;]: uma conversão [.toJS] adicional, além das funções apenas, que deve ser lembrada sempre que se manipular [innerHTML].
- linha 129: [(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(...)]: um RECORD posicional como tipo de retorno, para devolver dois elementos DOM de uma só vez sem uma classe intermediária — mais um uso prático dos records do Dart 3.
6.5.7. O controller: o arquivo [AppHtml.ts]
6.5.8. Script [app_html]
| // app_html.dart
// Porta AppHtml.ts: o controller da aplicação HTML. Ele orquestra as
// chamadas ao servidor (camada [dao], dao3.dart), os cálculos
// (camada [business], business.dart) e a exibição das views (camada [views],
// views.dart).
//
// Como main3.dart, este cliente chama o servidor NestJS para apenas três
// ações: [init-session], [authenticate-user] e [get-admindata].
// Uma vez recuperados os dados tributários (alíquotas, tetos...) com
// [get-admindata], é a camada [business] que calcula o imposto no
// navegador, sem nova chamada de rede. A lista de simulações também é
// mantida apenas no navegador (campo [simulations]),
// exatamente como main3.dart faz com sua variável local
// [simulations] (`simulations.add(...)`, `simulations.removeAt(...)`).
import 'dart:js_interop';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
import 'simulation.dart';
import 'views.dart';
import 'package:web/web.dart' as web;
class AppHtml {
final Dao3 dao;
final Views views;
// camada [business]: só existe depois que os dados tributários foram recuperados
// (após uma autenticação bem-sucedida) - veja [_initBusiness]. Um
// campo NULLABLE (Business?), e não um campo late ([late]): ao contrário de
// Views.ts, em que [business?: Business] simplesmente permanece "undefined" enquanto
// não for atribuído, um campo [late] do Dart lançaria um erro se fosse
// LIDO antes da atribuição (o que é justamente o que [_endSession] faz ao
// reinicializá-lo) - portanto o tipo nullable é a escolha certa aqui, e não
// apenas uma questão de estilo.
Business? _business;
// lista das simulações já calculadas, mantida no navegador
List<Simulation> _simulations = [];
// [diferença com o TypeScript] AppHtml.ts configura uma instância GLOBAL do axios
// (axios.defaults.timeout/baseURL/withCredentials) e depois a entrega
// ao Dao. Aqui, [BrowserClient] (package:http/browser_client.dart, já
// encontrado em main3.dart) carrega o equivalente de
// "axios.defaults.withCredentials = true"; não há equivalente direto de
// um "timeout global" em http.Client - ele seria aplicado caso
// a caso com `.timeout(Duration(...))` em cada chamada, como no
// capítulo sobre [http] (dart_fetch_01.dart).
AppHtml()
: dao = Dao3(
BrowserClient()..withCredentials = true,
'http://localhost:3000',
),
views = Views(web.document.getElementById('app') as web.HTMLElement);
// ponto de entrada da aplicação
Future<void> start() async {
try {
// inicialização da sessão - obrigatória antes de qualquer outra ação (veja main.php)
final response = await dao.initSession() as Map<String, dynamic>;
if (response['status'] != 700) {
views.authenticationView(
_formatError(response['response']),
(onSubmit: (user, password) => _authenticate(user, password)),
);
return;
}
} catch (error) {
views.authenticationView(
"Unable to contact the server ($error)",
(onSubmit: (user, password) => _authenticate(user, password)),
);
return;
}
// sessão inicializada: exibimos a autenticação
_showAuthentication();
}
// --------------------------------------------------------------------
// view de [autenticação]
// --------------------------------------------------------------------
void _showAuthentication([String? error]) {
views.authenticationView(
error,
(onSubmit: (user, password) => _authenticate(user, password)),
);
}
Future<void> _authenticate(String user, String password) async {
try {
final response = await dao.authenticateUser(user, password)
as Map<String, dynamic>;
if (response['status'] == 200) {
// autenticação bem-sucedida: como em main3.dart, agora recuperamos,
// de uma vez por todas, os dados tributários
// necessários à camada [business]
await _initBusiness();
} else {
// falha (login/senha incorretos ou parâmetros ausentes)
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// recupera os dados da administração tributária e instancia a
// camada [business] com esses dados - uma única chamada ao servidor para toda a
// sessão, exatamente como main3.dart
Future<void> _initBusiness() async {
try {
final response = await dao.getAdminData() as Map<String, dynamic>;
if (response['status'] == 1000) {
_business = Business(response['response'] as Map<String, dynamic>);
// nova sessão de trabalho: recomeçamos de uma lista vazia
_simulations = [];
_showCalculation();
} else {
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// --------------------------------------------------------------------
// view de [cálculo de imposto]
// --------------------------------------------------------------------
void _showCalculation([Simulation? result, String? error]) {
views.calculationView(
result,
error,
(
onSubmit: (married, children, salary) =>
_calculate(married, children, salary),
onList: () => _showList(),
onEndSession: () => _endSession(),
),
);
}
// cálculo do imposto feito inteiramente no navegador (camada [business]):
// nenhuma chamada ao servidor, ao contrário da primeira versão
// deste cliente (http client 1 / http client 2)
void _calculate(String married, int children, int salary) {
// _business necessariamente foi inicializado: só chegamos à view de [cálculo]
// depois de _initBusiness (portanto o [!] é seguro aqui, como o
// [!] do TypeScript em [this.business!])
final result = _business!.calculateTax(married, children, salary);
// [diferença com o TypeScript] Views.ts constrói a simulação com um
// simples spread de objeto: `{ married, children, salary, ...result }`.
// Aqui, [Simulation] é um RECORD (simulation.dart), e não um Map: um
// record não pode ser "completado" por spread de um Map, e
// seus campos são tipados (num, int...), enquanto
// [result], retornado por business.dart, é um Map sem tipos cujas chaves
// apenas TÊM os mesmos nomes ('tax', 'surcharge'..., veja business.dart). Portanto
// reconstruímos o record campo a campo - um pouco mais verboso
// que um spread, mas inteiramente verificado pelo compilador (um campo esquecido
// ou com tipo errado é um erro de compilação, e não uma surpresa em
// tempo de execução).
final Simulation simulation = (
married: married,
children: children,
salary: salary,
tax: result['tax'] as num,
surcharge: result['surcharge'] as num,
discount: result['discount'] as num,
reduction: result['reduction'] as num,
rate: result['rate'] as num,
);
// armazenamento no navegador (como `simulations.add(...)` em
// main3.dart)
_simulations.add(simulation);
_showCalculation(simulation);
}
// --------------------------------------------------------------------
// view de [lista de simulações]
// --------------------------------------------------------------------
// não há mais chamadas ao servidor aqui: a lista já está inteiramente em
// [_simulations]
void _showList([String? error]) {
views.listView(
_simulations,
error,
(
onDelete: (number) => _deleteSimulation(number),
onCalculation: () => _showCalculation(),
onEndSession: () => _endSession(),
),
);
}
void _deleteSimulation(int number) {
// exclusão local de [_simulations], como
// `simulations.removeAt(number)` em main3.dart - ainda sem chamada
// ao servidor
_simulations.removeAt(number);
_showList();
}
// --------------------------------------------------------------------
// fim da sessão
// --------------------------------------------------------------------
void _endSession() {
// fim da sessão apenas no lado do cliente: esquecemos a camada [business]
// (e, portanto, os dados tributários) e as simulações já calculadas, depois
// voltamos à tela de autenticação. Este cliente não precisa
// chamar o servidor para isso.
_business = null;
_simulations = [];
_showAuthentication();
}
// --------------------------------------------------------------------
// formata o campo [response] de uma resposta de erro do servidor, que
// é uma string ou uma lista de strings (veja os controllers PHP)
// --------------------------------------------------------------------
String _formatError(Object? response) {
if (response is List) {
return response.join(' ; ');
}
return '$response';
}
}
// execução - [diferença com o TypeScript] o manipulador de eventos
// passado a addEventListener deve ser convertido em uma função JavaScript com
// [.toJS] (veja views.dart); esta é apenas a versão "ponto de entrada" da
// mesma regra.
void main() {
web.window.addEventListener(
'DOMContentLoaded',
((web.Event event) {
AppHtml().start();
}).toJS,
);
}
|
Vamos comentar este código:
- linhas 46–51: [AppHtml() : dao = Dao3(BrowserClient()..withCredentials = true, ...), views = Views(...)]: construção do DAO e das VIEWS em uma LISTA DE INICIALIZAÇÃO - mesmo conceito do construtor TypeScript, usando a sintaxe específica do Dart [: field1 = ..., field2 = ...].
- Linha 34: [Business? _business;]: um campo NULLABLE, onde AppHtml.ts usava antes [business?: Business] - o mesmo conceito (“ainda não inicializado”), usando o mesmo operador [!] para confirmar que o campo está de fato preenchido em um ponto específico do código.
- Linhas 158–162: [final Simulation simulation = (married: married, ..., tax: result['tax'] as num, ...);]: diferentemente do spread simples [{ married, children, salary, ...result }] de AppHtml.ts, um RECORD não pode ser completado por um spread a partir de um [Map] - o record é, portanto, reconstruído CAMPO A CAMPO, o que é um pouco mais verboso, mas totalmente validado pelo compilador.
- Linhas 229–233: [web.window.addEventListener('DOMContentLoaded', ((web.Event event) { AppHtml().start(); }).toJS);]: o mesmo ponto de entrada de AppHtml.ts, com a mesma conversão de callback ([.toJS]) de views.dart.
6.5.9. Compilação e execução
Consulte o README.md nesta pasta: [dart pub get] seguido de [webdev serve] para desenvolvimento (incluindo hot reloading), ou [dart compile js web/main.dart -o web/main.dart.js] para um build de produção — o equivalente Dart de [npm run build], sem nenhuma etapa prévia de configuração de bundler.
Se o servidor [webdev serve] ainda estiver em execução para a aplicação web [http client 3], você deve interrompê-lo (Ctrl-C no terminal que o iniciou). Em seguida, em um terminal dentro do diretório [html client]:
| dart pub get
webdev serve
|
A linha 2 inicia o servidor web que servirá a aplicação cliente HTML:

- Em [1], no navegador, solicite a URL [http://localhost:8080];
- em [2-3], digite as credenciais admin / admin;
- Em [4], envie a página;

- Em [2], preencha os campos;
- Em [3], envie a página;

O valor do imposto é exibido em [1]. Execute várias simulações e, em seguida, solicite a lista em [2];

- Em [1], exclua uma simulação;

- em [1], encerre a sessão;

6.6. Conclusão
Os quatro clientes deste capítulo ilustram, com Dart, exatamente a mesma progressão que com TypeScript: do processamento no lado do servidor ao processamento no lado do cliente e, depois, do script CLI ao cliente web completo. As principais diferenças a observar são o acompanhamento manual do cookie de sessão (necessário no CLI, desnecessário em um navegador), a conversão [.toJS] imposta por [dart:js_interop] para fazer a ponte entre as fronteiras Dart/JavaScript nas views, e a ausência total de polyfills na compilação web — uma clara vantagem da toolchain Dart em relação ao pipeline webpack/babel.