6. Clientes HTTP para el servicio de cálculo de impuestos

6.1. Introducción
Este capítulo reproduce, sin cambios estructurales, las tres capas sucesivas de clientes construidas en el curso de TypeScript, cada una de las cuales refina la anterior: un primer cliente CLI, donde todos los cálculos permanecen del lado del servidor; un segundo cliente CLI, donde el cálculo pasa al lado del cliente (capa [business]); un tercer cliente, compilado para el NAVEGADOR; y, por último, un cliente HTML completo, con sus propias vistas. Los cuatro se apoyan en el mismo servidor NestJS, instalado en el capítulo anterior.
6.2. Cliente HTTP 1

6.2.1. La capa [dao]
6.2.2. script [dao1]
| // dao1.dart
// Porta Dao1.ts: la capa [dao] (Data Access Object) encapsula todos los
// detalles de la comunicación HTTP con el servidor de cálculo de impuestos (URL,
// método, cookie de sesión) detrás de métodos de negocio simples
// (initSession, authenticateUser, calculateTax...).
import 'package:dio/dio.dart';
class Dao1 {
final Dio _dio;
final String _sessionCookieName;
String _sessionCookie = '';
// constructor - recibe la instancia de Dio a utilizar, como el script de TypeScript
// recibía la instancia de axios como parámetro
Dao1(this._dio) : _sessionCookieName = "connect.sid";
// inicio de sesión
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 del impuesto
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 simulaciones
Future<dynamic> listSimulations() {
return _getRemoteData(
'main.php',
method: 'GET',
queryParameters: {'action': 'list-simulations'},
);
}
// eliminar una simulación
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 la cookie de sesión
final options = Options(
method: method,
contentType: contentType,
headers: {'Cookie': _sessionCookie},
validateStatus: (_) => true,
);
// ejecución de la solicitud HTTP
final response = await _dio.request(
path,
queryParameters: queryParameters,
data: data,
options: options,
);
// recuperamos la cookie de sesión si existe
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;
}
}
}
// la respuesta del servidor está en [response.data]
return response.data;
}
}
|
Comentemos este código:
- Línea 48: La capa [dao] (Data Access Object) encapsula todos los detalles de la comunicación HTTP (URL, método, cookie de sesión) detrás de métodos de negocio simples: [initSession], [authenticateUser], [calculateTax], [listSimulations], [deleteSimulation] (línea 57).
- Línea 15: [Dao1(this._dio)] recibe como parámetro del constructor la instancia de [Dio] que se va a usar, exactamente como el script de TypeScript recibía la instancia de [axios].
- Línea 65: [_getRemoteData] (privado, prefijo [_]) centraliza el seguimiento manual de la cookie de sesión ([response.headers['set-cookie']], [RegExp] (línea 90)) ya visto en dart_dio_03.dart: cada método público del DAO se apoya en este mismo método privado.
6.2.3. El [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 {
// configuración de Dio - baseUrl/timeout globales, como axios.defaults en
// TypeScript
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// instanciación de la capa [dao]
final dao = Dao1(dio);
// uso de la capa [dao]
try {
// inicio de sesión
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// autenticación
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// cálculos de impuestos - Future.wait es el equivalente en Dart de Promise.all
// (ya visto en 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 simulaciones
log("-----------list-of-simulations");
response = await dao.listSimulations();
log(response);
// eliminación de una simulación
log("-----------deleting simulation no. 1");
response = await dao.deleteSimulation(1);
log(response);
} catch (error) {
// registramos el error en el log
print("error=$error");
}
}
// log JSON
void log(Object? object) {
const JsonEncoder encoder = JsonEncoder.withIndent(' ');
print(encoder.convert(object));
}
|
Comentemos este código:
- línea 16: [final dao = Dao1(dio);]: la capa [dao] se instancia una sola vez y luego se reutiliza durante toda la secuencia de llamadas (init-session, autenticación, cálculos, lista, eliminación).
- Líneas 30–31: [Future.wait([dao.calculateTax(...), ...])]: los tres cálculos de impuestos se lanzan EN PARALELO, el equivalente en Dart de [Promise.all], ya visto en async_05.dart.
- Líneas 52–53: [JsonEncoder.withIndent(' ').convert(object)]: la función utilitaria [log] reproduce la visualización con sangría de [JSON.stringify(x, null, 2)].
El resultado de la ejecución es el siguiente:
| "-----------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 traslada el CÁLCULO del impuesto del servidor al cliente: el servidor ahora proporciona los datos fiscales en bruto (tasas, umbrales, etc.) una sola vez mediante [get-admindata], y es la capa [business] la que realiza los cálculos.
6.3.1. El [Business]
6.3.2. script [business]
| // business.dart
// Porta Business.ts: el cálculo del impuesto, realizado íntegramente del lado del cliente
// (en el navegador en TypeScript, aquí en el programa Dart), a partir de
// los datos fiscales en bruto obtenidos una sola vez del servidor mediante
// [Dao2.getAdminData] (ver dao2.dart).
class Business {
// [dynamic]: la estructura exacta de los datos enviados por el servidor
// de impuestos (tasas, topes...) no está documentada aquí; como en
// TypeScript, nos mantenemos deliberadamente flexibles con este tipo
final Map<String, dynamic> taxAdminData;
Business(this.taxAdminData);
// cálculo del impuesto
// --------------------------------------------------------------------------
// married: sí, no
// children: número de hijos
// salary: salario anual
Map<String, dynamic> calculateTax(String married, int children, num salary) {
// cálculo del impuesto con hijos
final result1 = _calculateTax2(married, children, salary);
final tax1 = result1['tax'] as num;
// cálculo del impuesto sin los hijos
Map<String, dynamic> result2;
num tax2;
num halfShareCeiling;
if (children != 0) {
result2 = _calculateTax2(married, 0, salary);
tax2 = result2['tax'] as num;
// aplicación del tope del cociente familiar
halfShareCeiling = taxAdminData['halfShareQfCeiling'] as num;
if (children < 3) {
// halfShareCeiling para los 2 primeros hijos
tax2 = tax2 - children * halfShareCeiling;
} else {
// halfShareCeiling para los 2 primeros hijos, el doble para los siguientes
tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
}
} else {
// sin nuevo cálculo del impuesto
tax2 = tax1;
result2 = result1;
}
// tomamos el mayor impuesto 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 un posible descuento
final discount = _getDiscount(married, tax);
tax -= discount;
// cálculo de una posible reducción de impuesto
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 hijo a partir del 3.º
if (children >= 3) {
// media parte adicional por cada hijo a partir del 3.º
shares += 0.5 * (children - 2);
}
// ingreso imponible
final taxableIncome = _getTaxableIncome(salary);
// recargo
num surcharge = (taxableIncome - 0.9 * salary).floor();
// por problemas de redondeo
if (surcharge < 0) {
surcharge = 0;
}
// cociente familiar
final quotient = taxableIncome / shares;
// cálculo del impuesto
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);
// se coloca al final de la lista [limits] para detener el bucle siguiente
limits[limits.length - 1] = quotient;
// búsqueda de la tasa de impuesto
var i = 0;
while (quotient > limits[i]) {
i++;
}
// como colocamos quotient al final de limits, el bucle anterior
// no puede salirse de la lista limits
// ahora podemos calcular el impuesto
final tax = (taxableIncome * coeffR[i] - shares * coeffN[i]).floor();
// resultado
return {'tax': tax, 'surcharge': surcharge, 'rate': coeffR[i]};
}
// taxableIncome = annualSalary - allowance (la deducción tiene un mínimo y un máximo)
num _getTaxableIncome(num salary) {
// deducción del 10% del salario
num allowance = 0.1 * salary;
// esta deducción no puede exceder tenPercentAllowanceMax
final allowanceMax = taxAdminData['tenPercentAllowanceMax'] as num;
if (allowance > allowanceMax) {
allowance = allowanceMax;
}
// la deducción no puede ser inferior a tenPercentAllowanceMin
final allowanceMin = taxAdminData['tenPercentAllowanceMin'] as num;
if (allowance < allowanceMin) {
allowance = allowanceMin;
}
// ingreso imponible
final taxableIncome = salary - allowance;
return taxableIncome.floor();
}
// calcula un posible descuento
num _getDiscount(String married, num taxes) {
// inicialmente, un descuento nulo
num discount = 0;
// monto máximo del impuesto para obtener el descuento
final taxCeilingForDiscount = married == "yes"
? taxAdminData['coupleTaxCeilingForDiscount'] as num
: taxAdminData['singleTaxCeilingForDiscount'] as num;
if (taxes < taxCeilingForDiscount) {
// monto máximo del descuento
final discountCeiling = married == "yes"
? taxAdminData['coupleDiscountCeiling'] as num
: taxAdminData['singleDiscountCeiling'] as num;
// descuento teórico
discount = discountCeiling - 0.75 * taxes;
// el descuento no puede exceder el monto del impuesto
if (discount > taxes) {
discount = taxes;
}
// ningún descuento < 0
if (discount < 0) {
discount = 0;
}
}
// resultado - ceil() es el equivalente en Dart de Math.ceil()
return discount.ceil();
}
// calcula una posible reducción
num _getReduction(String married, num salary, int children, num taxes) {
// el tope de ingresos para tener derecho a la reducción del 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;
}
// ingreso imponible
final taxableIncome = _getTaxableIncome(salary);
// reducción
num reduction = 0;
if (taxableIncome < incomeCeilingForReduction) {
// reducción del 20%
reduction = 0.2 * taxes;
}
return reduction.ceil();
}
}
|
Analicemos este código:
- línea 12: [Business(this.taxAdminData)]: el constructor recibe los datos fiscales en bruto recuperados por el DAO una sola vez; después ya no se requieren más llamadas de red para calcular un impuesto.
- línea 19: [Map<String, dynamic> calculateTax(String married, int children, num salary)]: una adaptación fiel, línea por línea, del algoritmo de TypeScript; los mismos pasos ([_calculateTax2], [_getTaxableIncome], [_getDiscount], [_getReduction]), la misma lógica para limitar el cociente familiar.
- [.floor()]/[.ceil()] (métodos de [num]) reemplazan a [Math.floor(...)]/[Math.ceil(...)]: en Dart son métodos de instancia del propio número, no métodos estáticos de una clase utilitaria.
- Las CLAVES del [Map] devuelto ([tax], [surcharge], [discount], [reduction]...) tienen los mismos nombres ASCII simples que los IDENTIFICADORES de Dart (nombres de variables y parámetros); una cadena puede contener acentos en Dart, pero un identificador no (vea simulation.dart, más adelante en este capítulo).
6.3.3. El [Dao2]
6.3.4. script [dao2]
| // dao2.dart
// Porta Dao2.ts: idéntico a dao1.dart para initSession y
// authenticateUser, pero expone [getAdminData] en lugar de
// [calculateTax]/[listSimulations]/[deleteSimulation] - el cálculo y
// la lista de simulaciones ahora los maneja del lado del CLIENTE la
// capa [business] (ver business.dart), y el servidor solo sirve para proporcionar los
// datos fiscales en bruto (tasas, topes...).
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;
}
}
|
Comentemos este código:
- línea 4: Idéntico a [Dao1] para [initSession] y [authenticateUser], pero expone [getAdminData] en lugar de [calculateTax]/[listSimulations] (línea 4)/[deleteSimulation] (línea 4): estas tres operaciones ahora se manejan del lado del CLIENTE mediante la capa [business] que acabamos de presentar.
6.3.5. El [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 {
// configuración de Dio
final dio = Dio(BaseOptions(
baseUrl: 'http://localhost:3000/',
connectTimeout: const Duration(seconds: 2),
receiveTimeout: const Duration(seconds: 2),
));
// instanciación de la capa [dao]
final dao = Dao2(dio);
// solicitudes HTTP
Map<String, dynamic> taxAdminData;
try {
// inicio de sesión
log("-----------init-session");
dynamic response = await dao.initSession();
log(response);
// autenticación
log("-----------authenticate-user");
response = await dao.authenticateUser("admin", "admin");
log(response);
// datos fiscales
log("-----------get-admindata");
response = await dao.getAdminData();
log(response);
taxAdminData = response['response'] as Map<String, dynamic>;
} catch (error) {
// registramos el error en el log
print("error=$error");
// fin
return;
}
// instanciación de la capa [business]
final business = Business(taxAdminData);
// cálculos de impuestos
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 simulaciones
log("-----------list-of-simulations");
log(simulations);
// eliminación de una simulación
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));
}
|
Comentemos este código:
- línea 41: [final business = Business(taxAdminData);]: la capa [business] se instancia una SOLA vez, inmediatamente después de recuperar los datos fiscales del servidor.
- [simulations.add(business.calculateTax(...));]: los cálculos de impuestos ya no implican NINGUNA llamada de red, a diferencia de main1.dart, donde cada cálculo era una solicitud HTTP independiente.
El resultado de la ejecución es el siguiente:
| "-----------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. Evolución de las herramientas desde 2019
Este tercer cliente usa el mismo par [dao]/[business] que el cliente HTTP 2, pero se COMPILA PARA EL NAVEGADOR en lugar de ejecutarse desde la línea de comandos. Al igual que en TypeScript, esta compilación requiere webpack y babel, así como polyfills ([core-js/stable], [regenerator-runtime/runtime]) para que el código moderno funcione en navegadores antiguos. Del lado de Dart, el SDK proporciona su propio compilador web ([dart compile js]): no se necesitan polyfills; [Future]/[async]/[await], records, patrones, etc., se compilan directamente al JavaScript equivalente, sea cual sea el destino.
6.4.2. Compilación y ejecución del proyecto
Desde la carpeta [http client 3]:
El servidor de desarrollo [webdev serve] no viene con el SDK de Dart: primero debe instalarse una vez, de forma global, el paquete [webdev] mediante [dart pub global activate webdev].
Este comando instala el ejecutable [webdev] en la caché global de pub, una carpeta que no se agrega automáticamente al PATH de Windows. Para agregarla allí de una vez por todas (para el usuario actual), abra un terminal de PowerShell y ejecute:
| [Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:LOCALAPPDATA\Pub\Cache\bin", "User")
|
Luego debe cerrar y volver a abrir el terminal (o VSCode) para que el nuevo PATH surta efecto. Después, siempre en la carpeta [http client 3]:
| dart pub get
webdev serve
|
En desarrollo, [webdev serve] inicia un servidor que recompila automáticamente con cada cambio (hot reload): el terminal muestra la URL que se debe abrir en un navegador (predeterminada: http://localhost:8080). Para una compilación de producción, sigue disponible el comando [dart compile js web/main.dart -o web/main.dart.js]: la página [web/index.html] carga entonces [main.dart.js] para probar el resultado; el mismo concepto que el punto de entrada mínimo [src/index.ts] del curso de TypeScript.
6.4.3. El script [main3]
6.4.4. script [main3]
| // main3.dart
// Porta main3.ts.
//
// [WARNING, fundamental difference with TypeScript] main3.ts necesitaba
// dos polyfills (core-js/stable, regenerator-runtime) para que
// async/await y las funcionalidades recientes de JavaScript funcionen en
// navegadores antiguos, una vez transpilado por babel/webpack. El
// compilador de Dart para la web (`dart compile js`) NO necesita ningún
// polyfill de este tipo: Future/async/await, Records, patrones...
// se compilan directamente a JavaScript equivalente o a WebAssembly,
// sea cual sea el destino - una ventaja directa de compilar a partir
// de un lenguaje y herramientas unificados, en lugar de transpilar
// JavaScript "moderno" a JavaScript "antiguo".
import 'dart:convert';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
Future<void> main() async {
// cliente HTTP específico del navegador, con withCredentials=true -
// el equivalente en 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();
}
// instanciación de la capa [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));
}
|
Comentemos este código:
- línea 22: [final client = BrowserClient()..withCredentials = true;]: [BrowserClient] ([package:http/browser_client.dart]) solo existe cuando el código se compila para la web; su opción [withCredentials] es el equivalente en Dart de [axios.defaults.withCredentials = true]; el NAVEGADOR gestiona entonces por sí solo la cookie de sesión.
- El compilador web de Dart no requiere NINGÚN polyfill (a diferencia de main3.ts): [Future]/[async]/[await] y las funcionalidades recientes del lenguaje se compilan directamente; un beneficio directo de partir de un lenguaje y un conjunto de herramientas unificados en lugar de transpilar de JavaScript moderno a JavaScript heredado.
6.4.5. El [Dao3]
6.4.6. script [dao3]
| // dao3.dart
// Porta tax client/http client 3/src/Dao3.ts.
//
// Diferencia con dao2.dart: este archivo está pensado para compilarse para el
// NAVEGADOR (con `dart compile js`, ver el README de esta carpeta), no para
// ejecutarse en la CLI con `dart run`. En un navegador, la COOKIE DE SESIÓN
// la maneja automáticamente el propio navegador (como en cualquier
// página web) en cuanto se permite su envío - por lo tanto, ya no hace falta
// el seguimiento MANUAL de cookies hecho a mano en dao1.dart/dao2.dart
// (exactamente el razonamiento, ya presente, que permitió a Dao3.ts
// eliminar todo el código de manejo de cookies de Dao2.ts).
//
// [mapping with TypeScript] "axios.defaults.withCredentials = true"
// (definido en main3.dart, no aquí) corresponde, del lado del paquete [http] de Dart, a
// la opción [withCredentials] del cliente específico para la web,
// [BrowserClient] (package:http/browser_client.dart) - una clase que
// existe SOLO cuando el código se compila para la web, a diferencia de
// http.Client, que funciona en todas partes.
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);
}
// [difference with the CLI client] ninguna lectura manual del encabezado
// set-cookie aquí: en un navegador, response.headers ni siquiera lo expone
// (encabezado protegido por el navegador, invisible para el
// código JavaScript/Dart, precisamente porque ya lo maneja el propio navegador)
return jsonDecode(response.body);
}
}
|
Comentemos este código:
- YA NO hay seguimiento manual de la cookie de sesión (a diferencia de [Dao1]/[Dao2]): en un navegador, la cookie de sesión es gestionada automáticamente por el propio navegador, siempre que se permita el envío de cookies ([withCredentials], establecido en main3.dart).
- [response.headers] ya ni siquiera expone el encabezado [set-cookie] en un navegador: un encabezado protegido, invisible para el código JavaScript/Dart del lado del cliente, precisamente porque ya se gestiona por sí solo.
6.4.7. Compilación y ejecución
Vea la sección [Compiling and Running the Project] más arriba: el mismo comando [dart compile js] compila [web/main.dart], que delega en [main3.dart].
Inicie el servidor de desarrollo para ejecutar la aplicación web del 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
|
El resultado de la ejecución es el siguiente:

- En [1], abra un navegador y solicite la URL [http://localhost:8080];
- en [2], el texto que muestra la página solicitada;
- en [3], el resultado de la ejecución se encuentra en la consola del navegador (F12 y luego la opción Console). Obtenemos el mismo resultado que antes, pero esta vez en un navegador;
6.5. Cliente HTML

6.5.1. Arquitectura de la solución
Este cuarto y último cliente agrega una verdadera interfaz HTML sobre el cliente HTTP 3: las capas [dao] ([Dao3]) y [business] ([Business]) se REUTILIZAN SIN MODIFICACIÓN, y se agregan dos capas nuevas: VISTAS (construcción del DOM) y CONTROLADOR (orquestación). El proyecto se organiza en dos carpetas, [web/] (punto de entrada, HTML, CSS) y [lib/] (código compartido), siguiendo la convención de un proyecto web estándar de Dart; consulte el README.md de esta carpeta para conocer los detalles de esta convención.
6.5.2. La plantilla HTML: el archivo [web/index.html]
Copiado exactamente de [src/index.html] (las mismas clases CSS: [banner], [menu], [content], [section-title], [field-row], [result], [error], [simulations]...), con una pequeña diferencia: el script que se carga es [main.dart.js] (un nombre FIJO establecido por la herramienta web de Dart), mientras que [index.html] de Views.ts cargaba un bundle de Webpack con un nombre con HASH ([main.a44f6e1c12ab338daedc.js]).
6.5.3. La configuración modificada [webpack.config.js]
No se necesita ningún equivalente del lado de Dart: no hay que escribir ningún archivo de configuración de empaquetador. [web/main.dart], por su sola POSICIÓN en el árbol de directorios (directamente bajo [web/]), cumple el papel que la línea [entry: './src/main3.ts'] cumplía para [webpack.config.js]; una convención de nombres y ubicación reemplaza todo un archivo de configuración.
6.5.4. Las capas [dao] y [business]: dos archivos reutilizados sin modificación
[lib/dao3.dart] y [lib/business.dart] son copias EXACTAS de los archivos del mismo nombre del cliente HTTP 3; la misma reutilización, sin ninguna modificación, que la realizada por Views.ts y AppHtml.ts sobre [Dao3.ts] y [Business.ts].
6.5.5. La capa [views]: el [Views.ts]
6.5.6. scripts [simulation, views]
La capa de vistas se apoya en TRES archivos: simulation.dart (los datos mostrados), views.dart (la construcción del DOM) y app_html.dart (el controlador, tratado en la sección siguiente). Comencemos con simulation.dart:
| // simulation.dart
// El resultado de un cálculo de impuestos, tal como lo devuelve business.dart,
// completado con los parámetros ingresados. Porta la interfaz [Simulation] de Views.ts.
//
// [NEW, Dart 3] aquí usamos un RECORD con nombre (ver
// dart-fundamentals/dart3/dart3_01_records.dart) en lugar de una clase: un
// simple alias de tipo [typedef], sin constructor ni archivo aparte
// que escribir, para datos que son solo una simple "bolsa" de campos, sin comportamiento
// asociado - exactamente el espíritu de la
// interfaz original de TypeScript.
//
// [NOTE on field names] a diferencia de TypeScript/JavaScript, donde
// un identificador puede contener letras con acento (usadas en todo el
// curso original en francés), Dart restringe
// los identificadores a letras ASCII: los acentos solo son posibles en
// CADENAS DE CARACTERES, nunca en el nombre de una
// variable, campo, clase o record. En cualquier caso, este curso
// usa nombres ASCII simples en inglés en todas partes (married, tax, discount...):
// los campos del record a continuación tienen los mismos nombres que las claves del Map de
// business.dart.
typedef Simulation = ({
String married,
int children,
num salary,
num tax,
num surcharge,
num discount,
num reduction,
num rate,
});
|
Analicemos este código:
- líneas 21–24: [typedef Simulation = ({String married, int children, num salary, ...});]: mientras que Views.ts declaraba una INTERFAZ [Simulation], este archivo usa un RECORD CON NOMBRES de Dart 3 (vea dart3_01_records.dart); un simple alias de tipo, sin constructor ni archivo separado, para datos puramente descriptivos.
- Los nombres de los campos son ASCII simples ([married], [tax], [discount]...): los IDENTIFICADORES de Dart están restringidos a letras ASCII, a diferencia de TypeScript/JavaScript, donde nombres con acentos como [marié]/[impôt] (usados en el curso original en francés) son nombres de campo válidos.
[lib/views.dart], compuesto por DOM y [package:web]:
| // views.dart
// Porta Views.ts: construcción de las vistas (DOM) de la aplicación - vista de
// autenticación, vista de cálculo de impuestos, vista de lista de simulaciones. Este
// módulo no hace ninguna llamada de red: construye el DOM y delega las acciones del
// usuario en funciones callback proporcionadas por el
// controlador (ver app_html.dart).
//
// [technical choice] aquí usamos [package:web] (pub.dev/packages/web),
// el reemplazo moderno del antiguo dart:html: expone una API del DOM muy
// cercana al DOM estándar usado por Views.ts (document.createElement,
// .textContent, .addEventListener...). Una diferencia superficial que
// conviene conocer: un manejador de eventos de Dart (una función simple) debe
// convertirse en una función de JavaScript con [.toJS] (extensión de
// dart:js_interop) antes de pasarse a [addEventListener] - el "puente"
// entre el mundo Dart y el mundo JavaScript, hecho explícito, mientras que
// TypeScript no necesita ninguna conversión (allí todo ya es
// JavaScript).
import 'dart:js_interop';
import 'package:web/web.dart' as web;
import 'simulation.dart';
// una decoración genérica (no la foto del 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 de la vista [authentication] - [difference with TypeScript]
// una interfaz de callbacks de TypeScript se traduce naturalmente en un
// RECORD de funciones en Dart (ver simulation.dart): más ligero que una
// clase, para un simple grupo de funciones
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;
// construye la estructura fija de la página (banner + área de menú/contenido)
// dentro del elemento [root]
Views(this.root) {
// [WARNING] a diferencia de las propiedades ordinarias del DOM (textContent,
// value...), el setter [innerHTML] de package:web espera un [JSAny], no
// un [String] de Dart sin procesar - una peculiaridad de su generación vinculada al
// atributo WebIDL [LegacyNullToEmptyString] del DOM estándar: por lo tanto,
// siempre debemos convertir con [.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);
}
// --------------------------------------------------------------------
// herramientas de construcción del 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;
}
// una fila de formulario [label + text/password/number field]
(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);
}
// --------------------------------------------------------------------
// vista de [authentication]
// --------------------------------------------------------------------
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);
}
// --------------------------------------------------------------------
// vista de [tax calculation]
// --------------------------------------------------------------------
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);
// fila de los 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 de la última simulación (recuadro verde), si existe
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);
}
}
// --------------------------------------------------------------------
// vista de [list of simulations]
// --------------------------------------------------------------------
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);
}
}
|
Analicemos este código:
- línea 19: [import 'package:web/web.dart' as web;]: el reemplazo moderno del antiguo [dart:html], con una API y un DOM muy similares al DOM estándar usado por Views.ts ([document.createElement], [.textContent], [.addEventListener]...).
- Líneas 44–45: [typedef CalculationCallbacks = ({void Function(...) onSubmit, ...});]: una interfaz de callbacks de TypeScript se traduce naturalmente en un RECORD DE FUNCIONES en Dart 3; más ligero que una clase para un simple grupo de funciones.
- Línea 108: [a.addEventListener('click', ((web.Event event) { ... }).toJS);]: un manejador de eventos de Dart (una simple función) debe convertirse en la función de JavaScript mediante [.toJS] (una extensión de [dart:js_interop]) antes de pasarse a [addEventListener]; el “puente” entre el mundo Dart y el mundo JavaScript se hace explícito, mientras que TypeScript no requiere ninguna conversión.
- línea 141: [input.value = initialValue;], [title.textContent = '...';] (línea 76): la mayoría de las propiedades de tipo cadena siguen siendo simples cadenas de Dart, sin conversión necesaria. [innerHTML] es la EXCEPCIÓN: [dart analyze] lo señala si se le asigna directamente un [String]; su setter espera un [JSAny] (una peculiaridad de su generación, relacionada con el atributo WebIDL [LegacyNullToEmptyString] del DOM estándar)—de ahí [root.innerHTML = ''.toJS;]: una conversión [.toJS] adicional, más allá de las funciones solas, que debe tenerse presente siempre que se manipule [innerHTML].
- línea 129: [(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(...)]: un REGISTRO posicional como tipo de retorno, para devolver dos elementos del DOM a la vez sin una clase intermedia—otro uso práctico más de los registros de Dart 3.
6.5.7. El controlador: el archivo [AppHtml.ts]
6.5.8. Script [app_html]
| // app_html.dart
// Porta AppHtml.ts: el controlador de la aplicación HTML. Orquesta las
// llamadas al servidor (capa [dao], dao3.dart), los cálculos
// (capa [business], business.dart) y la visualización de las vistas (capa [views],
// views.dart).
//
// Como main3.dart, este cliente llama al servidor NestJS solo para tres
// acciones: [init-session], [authenticate-user] y [get-admindata].
// Una vez recuperados los datos fiscales (tasas, topes...) con
// [get-admindata], es la capa [business] la que calcula el impuesto en el
// navegador, sin nuevas llamadas de red. La lista de simulaciones también se
// mantiene solo en el navegador (campo [simulations]),
// exactamente como lo hace main3.dart con su variable 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;
// capa [business]: solo existe una vez recuperados los datos fiscales
// (después de una autenticación exitosa) - ver [_initBusiness]. Un
// campo NULABLE (Business?), no un campo diferido ([late]): a diferencia de
// Views.ts, donde [business?: Business] simplemente permanece "undefined" mientras
// no se le asigne un valor, un campo [late] de Dart lanzaría un error si se
// LEYERA antes de la asignación (que es precisamente lo que hace [_endSession] cuando
// lo reinicia) - por lo tanto, el tipo nulable es la elección correcta aquí, no
// solo una cuestión de estilo.
Business? _business;
// lista de las simulaciones ya calculadas, mantenida en el navegador
List<Simulation> _simulations = [];
// [difference with TypeScript] AppHtml.ts configura una instancia GLOBAL de axios
// (axios.defaults.timeout/baseURL/withCredentials) y luego se la entrega
// al Dao. Aquí, [BrowserClient] (package:http/browser_client.dart, ya
// visto en main3.dart) lleva el equivalente de
// "axios.defaults.withCredentials = true"; no hay un equivalente directo de un
// "timeout global" en http.Client - se aplicaría caso
// por caso con `.timeout(Duration(...))` en cada llamada, como en el capítulo
// de [http] (dart_fetch_01.dart).
AppHtml()
: dao = Dao3(
BrowserClient()..withCredentials = true,
'http://localhost:3000',
),
views = Views(web.document.getElementById('app') as web.HTMLElement);
// punto de entrada de la aplicación
Future<void> start() async {
try {
// inicio de sesión - obligatorio antes de cualquier otra acción (ver 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;
}
// sesión inicializada: mostramos la autenticación
_showAuthentication();
}
// --------------------------------------------------------------------
// vista de [authentication]
// --------------------------------------------------------------------
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) {
// autenticación exitosa: como en main3.dart, ahora recuperamos,
// de una vez por todas, los datos fiscales
// que necesita la capa [business]
await _initBusiness();
} else {
// fallo (login/contraseña incorrectos, o parámetros faltantes)
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// recupera los datos de la administración fiscal e instancia la
// capa [business] con estos datos - una sola llamada al servidor para toda la
// sesión, exactamente 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>);
// nueva sesión de trabajo: partimos de nuevo de una lista vacía
_simulations = [];
_showCalculation();
} else {
_showAuthentication(_formatError(response['response']));
}
} catch (error) {
_showAuthentication("Unable to contact the server ($error)");
}
}
// --------------------------------------------------------------------
// vista de [tax calculation]
// --------------------------------------------------------------------
void _showCalculation([Simulation? result, String? error]) {
views.calculationView(
result,
error,
(
onSubmit: (married, children, salary) =>
_calculate(married, children, salary),
onList: () => _showList(),
onEndSession: () => _endSession(),
),
);
}
// cálculo del impuesto realizado íntegramente en el navegador (capa [business]):
// sin llamada al servidor, a diferencia de la primera versión
// de este cliente (http client 1 / http client 2)
void _calculate(String married, int children, int salary) {
// _business necesariamente ha sido inicializado: solo llegamos a la vista de [calculation]
// después de _initBusiness (por lo que el [!] es seguro aquí, como el [!] de TypeScript
// en [this.business!])
final result = _business!.calculateTax(married, children, salary);
// [difference with TypeScript] Views.ts construye la simulación con un
// simple spread de objeto: `{ married, children, salary, ...result }`.
// Aquí, [Simulation] es un RECORD (simulation.dart), no un Map: un
// record no puede "completarse" con el spread de un Map, y
// sus campos están tipados (num, int...) mientras que
// [result], devuelto por business.dart, es un Map sin tipar cuyas claves
// simplemente TIENEN los mismos nombres ('tax', 'surcharge'..., ver business.dart). Por lo tanto,
// reconstruimos el record campo por campo - un poco más verboso
// que un spread, pero completamente verificado por el compilador (un campo olvidado
// o con tipo incorrecto es un error de compilación, no una sorpresa en
// tiempo de ejecución).
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,
);
// almacenamiento en el navegador (como `simulations.add(...)` en
// main3.dart)
_simulations.add(simulation);
_showCalculation(simulation);
}
// --------------------------------------------------------------------
// vista de [list of simulations]
// --------------------------------------------------------------------
// ya no hay llamadas al servidor aquí: la lista ya está completamente en
// [_simulations]
void _showList([String? error]) {
views.listView(
_simulations,
error,
(
onDelete: (number) => _deleteSimulation(number),
onCalculation: () => _showCalculation(),
onEndSession: () => _endSession(),
),
);
}
void _deleteSimulation(int number) {
// eliminación local de [_simulations], como
// `simulations.removeAt(number)` en main3.dart - sigue sin haber ninguna llamada
// al servidor
_simulations.removeAt(number);
_showList();
}
// --------------------------------------------------------------------
// fin de sesión
// --------------------------------------------------------------------
void _endSession() {
// fin de sesión solo del lado del cliente: olvidamos la capa [business]
// (y por lo tanto los datos fiscales) y las simulaciones ya calculadas, y luego
// volvemos a la pantalla de autenticación. Este cliente no necesita
// llamar al servidor para esto.
_business = null;
_simulations = [];
_showAuthentication();
}
// --------------------------------------------------------------------
// formatea el campo [response] de una respuesta de error del servidor, que
// es una cadena o una lista de cadenas (ver los controladores PHP)
// --------------------------------------------------------------------
String _formatError(Object? response) {
if (response is List) {
return response.join(' ; ');
}
return '$response';
}
}
// ejecución - [difference with TypeScript] el manejador de eventos
// pasado a addEventListener debe convertirse en una función de JavaScript con
// [.toJS] (ver views.dart); esta es solo la versión de "punto de entrada" de
// la misma regla.
void main() {
web.window.addEventListener(
'DOMContentLoaded',
((web.Event event) {
AppHtml().start();
}).toJS,
);
}
|
Comentemos este código:
- líneas 46–51: [AppHtml() : dao = Dao3(BrowserClient()..withCredentials = true, ...), views = Views(...)]: construcción del DAO y de las VISTAS en una LISTA DE INICIALIZADORES - el mismo concepto que el constructor de TypeScript, con la sintaxis propia de Dart [: field1 = ..., field2 = ...].
- Línea 34: [Business? _business;]: un campo NULABLE, donde AppHtml.ts usaba antes [business?: Business] - el mismo concepto («aún no inicializado»), con el mismo operador [!] para confirmar que efectivamente tiene un valor en un punto específico del código.
- Líneas 158–162: [final Simulation simulation = (married: married, ..., tax: result['tax'] as num, ...);]: a diferencia del simple spread [{ married, children, salary, ...result }] de AppHtml.ts, un REGISTRO no se puede completar mediante un spread a partir de un [Map]; por lo tanto, el registro se reconstruye CAMPO POR CAMPO, lo cual es un poco más extenso pero está totalmente validado por el compilador.
- Líneas 229–233: [web.window.addEventListener('DOMContentLoaded', ((web.Event event) { AppHtml().start(); }).toJS);]: el mismo punto de entrada que en AppHtml.ts, con la misma conversión de callback ([.toJS]) que en views.dart.
6.5.9. Compilación y ejecución
Consulte README.md en esta carpeta: [dart pub get] seguido de [webdev serve] para el desarrollo (incluida la recarga en caliente), o [dart compile js web/main.dart -o web/main.dart.js] para una compilación de producción—el equivalente en Dart de [npm run build], sin ningún paso previo de configuración de un empaquetador.
Si el servidor [webdev serve] de la aplicación web [http client 3] sigue en ejecución, debe detenerlo (Ctrl-C en el terminal que lo inició). Luego, en un terminal dentro del directorio [html client]:
| dart pub get
webdev serve
|
La línea 2 inicia el servidor web que servirá la aplicación cliente HTML:

- En [1], en un navegador, solicite la URL [http://localhost:8080];
- en [2-3], ingrese las credenciales admin / admin;
- En [4], envíe la página;

- En [2], complete los campos;
- En [3], envíe la página;

El monto del impuesto se muestra en [1]. Realice varias simulaciones y luego solicite la lista en [2];

- En [1], elimine una simulación;

- en [1], finalice la sesión;

6.6. Conclusión
Los cuatro clientes de este capítulo ilustran, con Dart, exactamente la misma progresión que con TypeScript: del procesamiento del lado del servidor al procesamiento del lado del cliente, y luego del script CLI al cliente web completo. Las diferencias clave que conviene retener son el seguimiento manual de la cookie de sesión (necesario en CLI, innecesario en un navegador), la conversión [.toJS] impuesta por [dart:js_interop] para cruzar la frontera entre Dart y JavaScript en las vistas, y la ausencia total de polyfills en la compilación web—una clara ventaja de la cadena de herramientas de Dart frente al pipeline webpack/babel.