6. Clientes HTTP del servicio de cálculo de impuestos

6.1. Introducción
En esta sección escribiremos un cliente [node.js] para el servicio de cálculo de impuestos configurado en el capítulo “Instalación de un servidor NestJS”. La arquitectura cliente/servidor será la siguiente:

Examinaremos dos versiones del cliente:
- La versión 1 del cliente tendrá la siguiente estructura en capas: [main, dao]:

- La versión 2 del cliente tendrá la estructura [main, business, dao]. La capa del servidor [business] se trasladará al cliente:

6.2. Cliente HTTP 1

Como se mencionó, el cliente HTTP 1 implementa la siguiente arquitectura cliente/servidor:

Implementaremos:
- la capa [dao] como una clase;
- la capa [main] como un script que usa esa clase;
6.2.1. La capa [dao]
La capa [dao] se implementará mediante la siguiente clase, [Dao1.ts]:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | |
- Aquí aplicamos lo aprendido en el capítulo sobre las funciones HTTP de TypeScript;
- Líneas 14–20: el constructor de la clase. Esta clase tendrá tres propiedades:
- [axios]: el objeto [axios] utilizado para hacer las solicitudes HTTP. Lo pasa el código que realiza la llamada;
- [sessionCookieName]: según el servidor, la cookie de sesión puede tener nombres distintos. Aquí es [PHPSESSID];
- [sessionCookie]: la cookie de sesión enviada por el servidor y almacenada por el cliente;
- líneas 62–85: la función asíncrona [calculateTax] realiza la solicitud [post /main.php?action=calculate-tax] enviando por POST los parámetros [married, children, salary]. Devuelve como objeto JavaScript la cadena jSON transmitida por el servidor;
- líneas 88–102: la función asíncrona [listSimulations] realiza la solicitud [get /main.php?action=list-simulations]. Devuelve como objeto JavaScript la cadena jSON enviada por el servidor;
- líneas 105–120: la función asíncrona [deleteSimulation] realiza la solicitud [get /main.php?action=delete-simulation&number=index]. Devuelve como objeto JavaScript la cadena jSON enviada por el servidor;
- línea 132: la notación [this.axios] se usa porque aquí el objeto [axios] pasado al constructor se almacenó en la propiedad [this.axios] (línea 9);
- línea 172: la clase [Dao1] se exporta para poder utilizarla;
6.2.2. El script [main1]
Este script encadena una serie de llamadas al servidor mediante la clase Dao1: inicialización de la sesión, autenticación, tres cálculos de impuestos (en paralelo), una lista de simulaciones y la eliminación de una de ellas:
Comentarios
- línea 3: se importa la biblioteca [axios];
- línea 5: importa la clase [Dao];
- línea 9: la función [main], que se comunica con el servidor, es asíncrona;
- Líneas 11–12: configuración predeterminada de las solicitudes HTTP que se enviarán al servidor:
- línea 9: [timeout] con un tiempo de espera de 2 segundos;
- línea 10: todas las solicitudes de URL tienen como prefijo la URL base del servidor de cálculo de impuestos (http://localhost:3000);
- línea 14 : se construye la capa [Dao]. Ya puede utilizarse;
- líneas 48–50: la función [log] está diseñada para mostrar de forma formateada la cadena jSON de un objeto JavaScript: en vertical, con una sangría de dos espacios (tercer parámetro);
- líneas 17–20: inicialización de la sesión jSON;
- Líneas 21–24: autenticación;
- líneas 25–32: se solicitan tres cálculos de impuestos en paralelo. Gracias a [await Promise.all], la ejecución se bloquea hasta que se hayan obtenido los tres resultados;
- líneas 33–36: lista de simulaciones;
- líneas 37–40: eliminación de una simulación;
- líneas 41–44: manejo de las posibles excepciones;
Los resultados de la ejecución son los siguientes:
Resultado de la ejecución:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 | |
6.3. Cliente HTTP 2

La arquitectura del cliente HTTP 2 es la siguiente:

La capa [business] se ha trasladado del servidor al cliente JavaScript. Aquí, la capa [main] no necesitará pasar por la capa [business] para llegar a la capa [dao]. Usaremos estas dos capas como centros de especialización:
- la capa [main] pasa por la capa [dao] siempre que necesita datos que están en el servidor;
- la capa [main] solicita a la capa [business] que realice los cálculos de impuestos;
- La capa [business] es independiente de la capa [dao] y nunca recurre a ella;
6.3.1. La clase [Business]
La lógica del cálculo de impuestos sigue de cerca la de la clase PHP del curso “Introduction to the PHP7 Language Through Examples”; no la detallaremos de nuevo aquí, solo nos interesa su traducción a TypeScript:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | |
- línea 8: taxAdminData: any : la estructura exacta de los datos enviados por el servidor de impuestos (tasas, umbrales, etc.) no está documentada; por lo tanto, mantenemos deliberadamente flexible este tipo en lugar de especular sobre una interfaz incierta;
- La clase [Business] se exporta en la línea 191;
6.3.2. La clase [Dao2]

La clase [Dao2] implementa la capa [dao] del cliente JavaScript anterior de la siguiente manera:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 | |
Comentarios
- La clase [Dao2] implementa solo tres de las posibles solicitudes al servidor de cálculo de impuestos:
- [init-session] (líneas 21–35): para inicializar la sesión jSON;
- [authenticate-user] (líneas 37–57): para autenticarse;
- [get-admindata] (líneas 59–73): para recuperar los datos de la administración tributaria que permitirán realizar los cálculos de impuestos del lado del cliente;
Ahora usaremos Postman (véase la sección “Pruebas con Postman”) para demostrar cómo funciona la acción [get-admindata]. Si aún no lo ha hecho, importe en Postman (Ctrl-O) la colección de solicitudes HTTP, almacenada en el archivo [tax-servers-tests.postman_collection.json] de la carpeta [php_server]:
![]() | ![]() |
Luego ejecute en orden las tres consultas [2-4] indicadas arriba.
La consulta [4] es la siguiente:
![]() |
El resultado de esta consulta es el siguiente:
El contenido de las dos tablas de la base de datos está disponible en forma jSON.
6.3.3. El script [main2]

Este script inicializa la sesión, se autentica, recupera los datos tributarios y luego realiza los cálculos de impuestos localmente mediante la capa business; estos cálculos ya no involucran al servidor:
- línea 30: taxAdminData = response.response : los datos tributarios, recibidos una sola vez del servidor, se reutilizan luego localmente para todos los cálculos;
- línea 39: const business = new Business(taxAdminData) : la capa de negocio se instancia con estos datos, sin volver a hacer jamás una solicitud de red;
- líneas 44–46: los tres cálculos de impuestos son ahora sincrónicos y se ejecutan directamente en el navegador o en node.js, sin pasar por el servidor.
Resultado de la ejecución:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | |
6.4. Cliente HTTP 3
![]() |
En esta sección ejecutamos la aplicación [HTTP client 2] en un navegador según la siguiente arquitectura:

Mientras que [node.js] ejecuta TypeScript de forma nativa mediante tsx, este no es el caso de los navegadores: se requiere una herramienta para compilar TypeScript a JavaScript y luego ensamblar todo en un único archivo que pueda utilizar una página HTML. Este es el papel de [webpack].
Nota: la operación [1] descrita arriba será una solicitud HTTP generada por el código JavaScript de una página HTML. Veremos en breve que esta página HTML se obtiene mediante la URL [http://localhost:8080] (o 8081), solicitada a un servidor interno lanzado por [webpack]. El servidor de cálculo de impuestos, por su parte, es una aplicación NestJS accesible en la URL [http://localhost:3000] (véase Instalación de un servidor NestJS). Así pues, tenemos aquí dos aplicaciones web que se comunican entre sí, ambas accedidas mediante [http://localhost] pero no desde el mismo puerto. Decimos que están en dominios distintos. Este tipo de solicitud entre dos aplicaciones web en dominios diferentes está controlado. De forma predeterminada, el servidor NestJS rechazará las solicitudes de un cliente web si este no comparte el mismo origen que el servidor, es decir, [http://localhost:3000]. Sin embargo, es posible configurar el servidor NestJS para que acepte estas solicitudes llamadas “entre dominios”. Aquí esto ya se ha hecho. Por eso el cliente JavaScript que se muestra a continuación funcionará. Puede consultar la configuración del servidor NestJS en el capítulo “Caso de estudio: el servidor de cálculo de impuestos en NestJS”, que muestra cómo configurarlo para aceptar solicitudes entre dominios.
6.4.1. Cambios en el conjunto de herramientas desde 2019
El documento original (2019) usaba [babel-loader] para transpilar el código ES6 a ES5, compatible con navegadores antiguos. Como nuestro proyecto ahora está escrito en TypeScript, reemplazamos babel-loader por [ts-loader], que admite de forma nativa la sintaxis de TypeScript (tipos, interfaces, etc.), algo que Babel ignora por completo.
El archivo [webpack.config.js] del proyecto (carpeta tax client/http client 3) configura el módulo [webpack]:
- línea 36: entry: "./src/index.ts" : Webpack parte de este archivo y sigue todas sus importaciones para construir el paquete final;
- líneas 42–44: resolve: { extensions: [".ts", ".js"] } : le indica a Webpack que también resuelva los archivos .ts aunque no se especifique la extensión en las importaciones;
- líneas 48–56: la regla que asocia cada archivo .ts de la carpeta src con el cargador [ts-loader]; es el reemplazo directo de babel-loader mencionado arriba.
El contenido del archivo [./src/index.ts] es el siguiente:
Tenga en cuenta que el código JavaScript se ejecutará en un navegador. Por lo tanto, la línea anterior no se escribirá en una terminal, sino en la consola del navegador que ejecuta este código.
El archivo [package.json] de este subproyecto es el siguiente. Tiene sus propios scripts y dependencias (ts-loader, TypeScript, así como core-js y regenerator-runtime, que son polyfills para garantizar la compatibilidad con navegadores antiguos):
- líneas 12–20: dependencias necesarias durante el desarrollo del proyecto (compilación);
-
líneas 21–26: dependencias necesarias durante la ejecución del proyecto;
-
línea 17: [webpack]: el orquestador. [webpack] realiza la transpilación de los códigos TypeScript → ES5 y luego ensambla todos los archivos resultantes en un único archivo;
- línea 18: [webpack-cli]: requerido por [webpack];
- línea 13: [@webpack-cli/init]: se usa para configurar [webpack];
- línea 19: [webpack-dev-server]: proporciona un servidor web de desarrollo que se ejecuta de forma predeterminada en los puertos 8080 u 8081. Cuando se modifican los archivos fuente, [webpack-dev-server] recarga automáticamente la aplicación web;
6.4.2. Compilación y ejecución del proyecto
El archivo [package.json] define tres tareas [npm]:
Estas tareas son reconocidas por [VSCode], que las ofrece para su ejecución. Pase el mouse sobre la tarea “build” en la línea 3:
![]() |
Basta con hacer clic en [Run Script] para ejecutar la tarea seleccionada. También puede escribir el siguiente comando:
en una terminal ubicada en la carpeta que contiene el archivo [package.json].
La tarea [build] crea una carpeta llamada [dist] (1) dentro del proyecto VSCode:
![]() |
- En [3]: el proyecto se compila en [dist/main.hash.js], y se crea una página llamada [dist/index.html] (2);
La página generada [index.html] es la siguiente:
Por lo tanto, esta página simplemente encapsula el archivo [main.hash.js] generado por [webpack].
El proyecto se ejecuta con la tarea [start]:
La página [dist/index.html] se carga entonces en un servidor, parte de la suite [webpack], que se ejecuta en el puerto 8080 u 8081 de la máquina local y se muestra en el navegador predeterminado de la máquina:
![]() |
- en [2], el puerto de servicio del servidor web de [webpack];
- en [3-4], la pestaña [console] de las herramientas para desarrolladores del navegador, en este caso Microsoft Edge (se abre con F12);
- en [5], el resultado de ejecutar el archivo [src/index.ts]. Recuerde que el contenido de ese archivo era el siguiente:
Ahora cambiemos ese contenido por la siguiente línea en [index.ts]:
y guardemos el archivo. Automáticamente (sin recompilar), se genera un nuevo archivo llamado [index.html] y este nuevo archivo, [index.html], se carga en el navegador:
![]() |
No es necesario ejecutar la tarea [build] antes de la tarea [start]: esta última compila primero el proyecto. No almacena el resultado de esta compilación en la carpeta [dist]. Para comprobarlo, basta con eliminar esa carpeta. Verá entonces que la tarea [start] compila y ejecuta el proyecto sin crear la carpeta [dist]. Parece que almacena su resultado [index.html, main.hash.js] en una carpeta propia de [webpack-dev-server]. Este comportamiento es suficiente para nuestras pruebas.
Cuando el servidor de desarrollo está en ejecución, cualquier cambio guardado en uno de los archivos del proyecto provoca una recompilación. Por esta razón, desactivamos el modo [Auto Save] de [VSCode]. Esto se debe a que no queremos que se produzca una recompilación cada vez que se escriben caracteres en uno de los archivos del proyecto. Solo queremos que se produzca una recompilación cuando se guardan los cambios:

- En [2], la opción [Auto Save] no debe estar marcada;
6.4.3. Prueba del cliente web JavaScript del servidor de cálculo de impuestos
Para probar el cliente web JavaScript del servidor de cálculo de impuestos, debe especificar [main3.ts] [1] como punto de entrada del proyecto en el archivo [webpack.config.js] [2-3]:
![]() | ![]() |
- En [1], el script [main3.ts];
- en [2-3], la entrada [entry] que se debe modificar en el archivo de configuración de [webpack];
6.4.3.1. El script [main3]
Este script usa el contenido de main2.ts (capítulo anterior), adaptado para un navegador (importando polyfills):
- Líneas 3–4: import "core-js/stable" y import "regenerator-runtime/runtime" : los polyfills necesarios para que el código compilado funcione en navegadores que aún no implementan de forma nativa todas las características más recientes del lenguaje;
- línea 15: axios.defaults.withCredentials = true : esencial en un navegador para que las cookies de sesión se transmitan automáticamente entre solicitudes, lo que el código hacía manualmente en las versiones anteriores (node.js no admite las cookies del navegador).
6.4.3.2. La clase [Dao3]
Como la cookie de sesión ahora la administra el módulo [axios], podemos eliminar el manejo de esta cookie de la clase [Dao]:
En este código ya no hay ningún manejo de cookies.
6.4.3.3. Compilación y ejecución
El archivo package.json define dos tareas de npm:
- [npm run build] : compila el proyecto; los archivos resultantes se colocan en dist/ (un archivo main.<hash>.js y un archivo index.html que lo integra automáticamente mediante html-webpack-plugin);
- [npm start] : inicia webpack-dev-server, compila el proyecto y lo sirve en http://localhost:8080, con recarga automática de la página cada vez que se guarda un archivo fuente.
Ejecutamos estas dos tareas. El resultado en la página [console] del navegador (se abre con F12) es el siguiente:
![]() |
6.5. Cliente HTML
![]() |
Las secciones anteriores usaron el cliente [http client 3] exclusivamente en modo consola: el script [main3.ts] se comunica con el servidor y luego muestra sus resultados mediante console.log, sin ninguna página visible en el navegador. Ahora construiremos un verdadero cliente gráfico, con pantallas (autenticación, cálculo de impuestos, lista de simulaciones).
Partiremos del proyecto cliente [http client 3] (los mismos archivos [package.json] y [tsconfig.json]) y reutilizaremos dos archivos existentes sin modificarlos: [Dao3.ts] (capa [dao]) y [Business.ts] (capa [business], ya tratada a propósito de [main3.ts]). Solo agregamos:
- un archivo llamado [src/index.html], que sirve como plantilla de la página (encabezado, estilos CSS, área donde se muestran las vistas);
- un nuevo archivo, [Views.ts], que construye los elementos HTML (formularios, tabla, mensajes de error) directamente en JavaScript, sin llamar nunca al servidor por sí mismo;
- un nuevo archivo, [AppHtml.ts], el controlador de la aplicación: coordina las capas [dao] y [business] , y luego ordena a la capa [views] que muestre el resultado;
- una modificación menor de [webpack.config.js] para que el proyecto compile este nuevo punto de entrada con la nueva plantilla HTML.
El cuarteto [dao] / [business] / [views] / controlador replica así, exactamente, la arquitectura en capas ya presentada en este curso: la capa [dao] para el acceso al servidor, la capa [business] para la lógica de la aplicación (cálculo del impuesto), y el script principal (aquí, la clase [AppHtml]) para la orquestación. Solo la capa [views] es realmente nueva: reemplaza la salida por consola por una salida en el navegador.
6.5.1. Arquitectura de la solución
Este cliente HTML funciona exactamente igual que [main3.ts], y esta es una decisión de diseño clave: solo llama al servidor (PHP) para tres acciones, siempre las mismas: init-session, authenticate-user y get-admindata. Sin embargo, el código del servidor (PHP) muestra que también es capaz de calcular el impuesto por sí mismo y de almacenar las simulaciones en su sesión (son las acciones calculate-tax, list-simulations y delete-simulation, que se encuentran en la carpeta [Controllers]), pero este cliente no las utiliza.
La razón es simple: una vez que los datos fiscales (tasas, umbrales, etc.) se han obtenido una sola vez mediante get-admindata, todo lo necesario para calcular el impuesto ya está en el navegador, gracias a la clase [Business] . Solicitar este cálculo al servidor para cada simulación exigiría un viaje de ida y vuelta evitable por la red; asimismo, dado que cada simulación calculada se almacena de inmediato en el navegador, volver a pedir la lista al servidor (list-simulations) no aportaría ningún valor. Por lo tanto, este cliente minimiza al máximo las solicitudes al servidor, exactamente el principio ya implementado en [main3.ts]:
- la capa [dao] ([Dao3.ts]) permanece sin cambios: sus tres métodos ya presentados arriba (initSession, authenticateUser y getAdminData) son suficientes; no se le agrega ninguno;
- inmediatamente después de una autenticación exitosa, getAdminData se llama una vez por todas, y su resultado se usa para construir un objeto Business (new Business(taxAdminData)), que se conserva durante toda la sesión de trabajo;
- cada cálculo de impuesto llama entonces directamente a business.calculateTax(married, children, salary), una función JavaScript ordinaria, ejecutada en el navegador, sin ninguna llamada de red;
- las simulaciones calculadas se almacenan en un simple arreglo JavaScript, mantenido en memoria por el controlador: un push por cálculo, un splice por eliminación, exactamente como lo hace [main3.ts] con sus instrucciones simulations.push(...) y simulations.splice(1, 1).
Una ligera diferencia con [main3.ts]: el método business.calculateTax devuelve únicamente los valores que ha calculado (tax, surcharge, discount, reduction, rate), no los parámetros ingresados por el usuario (married, children, salary). [main3.ts] no los necesita, ya que simplemente usa console.log; pero nuestra vista [List of simulations] debe mostrar estos tres parámetros en la tabla, de modo que el controlador se los agrega al propio resultado antes de almacenarlo (lo veremos en el código de [AppHtml.ts]).
Por último, la vista [End of session] tampoco llama ya al servidor: simplemente descarta el objeto [Business] y la lista de simulaciones, y luego vuelve a mostrar la pantalla de autenticación. Recuerde que las respuestas de las tres acciones del servidor que siguen en uso tienen siempre el mismo formato, que ya vimos en [main3.ts]: un objeto JSON { action, status, response }, donde response contiene el resultado solicitado (si tuvo éxito) o un mensaje de error: una cadena o un arreglo de cadenas, según el controlador PHP correspondiente.
6.5.1.1. La plantilla HTML: el archivo [src/index.html]
Un proyecto [webpack] que usa [html-webpack-plugin] (como es el caso aquí; véase el archivo [webpack.config.js]) puede partir de una página HTML ya preparada, una “plantilla”, en la que el plugin insertará automáticamente la etiqueta <script> que carga el paquete compilado. Hasta ahora, este proyecto no tenía plantilla: [html-webpack-plugin] generaba una página HTML mínima, vacía y sin estilos. Ahora proporcionamos una: el archivo [src/index.html], que contiene:
- un bloque <style> que contiene todo el formato de la aplicación (encabezado, menú, formularios, tabla, mensajes de error y de resultado);
- una única etiqueta <div id="app"></div> : es el único elemento HTML “visible” de la plantilla; el resto de la página (encabezado, formularios, tabla, etc.) lo genera dinámicamente en JavaScript la clase [Views], dentro de esta etiqueta.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 | |
Este es un archivo HTML/CSS estándar, sin nada específico de TypeScript, pero como el público de este curso es de nivel principiante, repasemos en detalle los puntos más importantes:
Las variables CSS (líneas 7–16):
- El bloque :root { --name: value; ... } declara variables CSS (también llamadas “propiedades personalizadas”): --light-blue, --light-green, etc.;
- luego se reutilizan en el resto de la hoja de estilos mediante la función var(...), por ejemplo, background: var(--banner-grey); en la línea 40;
- La ventaja: basta con cambiar el color una vez al inicio del archivo para que cambie en todos los lugares donde se usa, en lugar de tener que buscar cada código de color en todo el archivo.
La estructura general (líneas 29–87):
- #app (línea 29) limita el ancho de la aplicación y agrega un borde;
- .banner (línea 36) muestra el logotipo y el título uno al lado del otro mediante
display: flex; - .page-body (línea 56) divide el resto de la página en dos columnas flexibles: .menu (línea 61, ancho fijo de 160 píxeles) a la izquierda, y .content (línea 80, ancho variable) a la derecha. La clase .content.full-width (línea 85) oculta esta columna de menú en la vista de inicio de sesión, que no la necesita.
Clases reutilizadas por la capa [views] (líneas 90–210):
- .section-title (línea 90): el recuadro azul claro utilizado para los títulos “Autentíquese”, “Complete el siguiente formulario y luego envíelo” y “Lista de sus simulaciones”;
- .field-row (línea 99): una fila de formulario (etiqueta + campo de entrada);
- .result (línea 152): el recuadro verde claro que muestra el resultado de un cálculo de impuesto;
- .error (línea 161): el recuadro rojo claro que muestra un mensaje de error devuelto por el servidor;
- table.simulations (línea 171): el formato de la tabla de la vista “lista de simulaciones”, con sus enlaces azules “Eliminar” (regla table.simulations a.delete, línea 196).
Cada una de estas clases se encuentra en el código de la clase [Views] (className = '...' o classList.add('...')); es esta clase la que, en JavaScript, crea los elementos HTML y les aplica estas clases CSS.
6.5.1.2. El archivo [webpack.config.js] modificado
El archivo [webpack.config.js] ya se presentó completo anteriormente en este capítulo. Bastan dos pequeños cambios para que compile este nuevo cliente gráfico en lugar del script de prueba [main3.ts]:
- línea 4: entry: "./src/AppHtml.ts" reemplaza a entry: "./src/main3.ts"; el nuevo controlador sirve ahora como punto de entrada del paquete; el valor anterior se conserva justo debajo, como comentario (líneas 5–8), para que pueda volver fácilmente al script de prueba si es necesario;
- líneas 21–23: new HtmlWebpackPlugin({ template: ... }) reemplaza a new HtmlWebpackPlugin() (sin parámetros); le indicamos explícitamente que use nuestra plantilla [src/index.html] en lugar de generar una página HTML vacía.
6.5.1.3. Las capas [dao] y [business] : dos archivos reutilizados sin modificación
El archivo [Dao3.ts] no se modifica aquí: sus tres métodos ya presentados anteriormente en este capítulo (initSession, authenticateUser, getAdminData, más la utilidad getRemoteData) son exactamente lo que necesita este cliente gráfico; no se agrega ninguno.
[Business.ts] tampoco se modifica: es la misma clase [Business], con su método calculateTax(married, children, salary), que ya se presentó completo en el análisis de [main3.ts] (sección [Client HTTP 2]). Sin embargo, este cliente gráfico es el primero de este capítulo que realmente muestra en pantalla los resultados de este cálculo en lugar de simplemente registrarlos; es una oportunidad para verificar que la capa [views], presentada inmediatamente después, puede formatearlos correctamente.
6.5.1.4. La capa [views]: el archivo [Views.ts]
Este es el archivo más largo de este cliente, pero también el más fácil de entender una vez que se comprende su principio: la clase [Views] no realiza ninguna llamada de red; ni siquiera sabe que existe el servidor PHP. Su único propósito es construir, mediante las funciones del DOM (document.createElement, appendChild, classList...), los elementos HTML de las tres pantallas de la aplicación, dentro de la etiqueta <div id="app"> de la plantilla.
Cuando el usuario hace clic en un botón o en un enlace (“Enviar”, “Eliminar”, “Fin de sesión”, etc.), la clase [Views] tampoco sabe qué hacer con ese clic: simplemente llama a una función de devolución de llamada (callback) proporcionada por el controlador; es el controlador, [AppHtml.ts], descrito poco después, el que decide entonces qué hacer (llamar al servidor, cambiar de vista, etc.). Este desacoplamiento es lo que permite que [Views.ts] siga siendo independiente de la capa [dao].
'use strict';
// -----------------------------------------------------------------------
// construcción de las vistas (DOM) de la aplicación, basada en las
// capturas de pantalla del documento [web_application_views.odt]:
// - vista de autenticación
// - vista de cálculo del impuesto (formulario + resultado)
// - vista de lista de simulaciones
// Este módulo no realiza ninguna llamada de red: construye el DOM y delega
// las acciones del usuario (Enviar, Eliminar, enlaces del menú) en funciones
// callback proporcionadas por el controlador [App].
// -----------------------------------------------------------------------
// una decoración genérica (no la foto del servidor PHP original, que no
// tenemos): reemplácela si es necesario por el logotipo real en [Resources/]
const LOGO_SVG = `
<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
<circle cx="30" cy="30" r="29" fill="#eef1ec" stroke="#ccc" />
<g fill="none" stroke="#8a9a7a" stroke-width="2">
<path d="M30 46 C30 32 22 28 17 19" />
<path d="M30 46 C30 30 39 26 44 17" />
<path d="M30 46 C30 37 30 30 30 21" />
</g>
<g fill="#b9c9a6">
<circle cx="17" cy="19" r="4.5" />
<circle cx="44" cy="17" r="4.5" />
<circle cx="30" cy="19" r="4.5" />
</g>
</svg>`;
// resultado de un cálculo de impuesto tal como lo devuelve el servidor (véase [Simulation.php])
export interface Simulation {
married: string;
children: number;
salary: number;
tax: number;
surcharge: number;
discount: number;
reduction: number;
rate: number;
}
// callbacks de la vista [authentication]
export interface AuthenticationCallbacks {
onSubmit: (user: string, password: string) => void;
}
// callbacks de la vista [calculation]
export interface CalculationCallbacks {
onSubmit: (married: string, children: number, salary: number) => void;
onList: () => void;
onEndSession: () => void;
}
// callbacks de la vista [list]
export interface ListCallbacks {
onDelete: (number: number) => void;
onCalculation: () => void;
onEndSession: () => void;
}
class Views {
private banner: HTMLElement;
private menu: HTMLElement;
private content: HTMLElement;
// construye la estructura fija de la página (banner + área de menú/contenido)
// dentro del elemento [root]
constructor(private root: HTMLElement) {
this.root.innerHTML = '';
this.banner = document.createElement('div');
this.banner.className = 'banner';
const logo = document.createElement('div');
logo.className = 'logo';
logo.innerHTML = LOGO_SVG;
const title = document.createElement('h1');
title.textContent = 'Calculate your tax';
this.banner.appendChild(logo);
this.banner.appendChild(title);
const body = document.createElement('div');
body.className = 'page-body';
this.menu = document.createElement('div');
this.menu.className = 'menu';
this.content = document.createElement('div');
this.content.className = 'content';
body.appendChild(this.menu);
body.appendChild(this.content);
this.root.appendChild(this.banner);
this.root.appendChild(body);
}
// --------------------------------------------------------------------
// herramientas de construcción del DOM
// --------------------------------------------------------------------
private clearMenu(): void {
this.menu.innerHTML = '';
this.menu.style.display = 'none';
this.content.classList.add('full-width');
}
private menuLink(text: string, onClick: () => void): HTMLAnchorElement {
const a = document.createElement('a');
a.textContent = text;
a.addEventListener('click', onClick);
return a;
}
private showMenu(links: HTMLAnchorElement[]): void {
this.menu.innerHTML = '';
this.menu.style.display = '';
this.content.classList.remove('full-width');
links.forEach(link => this.menu.appendChild(link));
}
private errorBanner(message?: string): HTMLElement | null {
if (!message) {
return null;
}
const div = document.createElement('div');
div.className = 'error';
div.textContent = message;
return div;
}
// una fila de formulario [etiqueta + campo de texto/contraseña/número]
private fieldRow(
labelText: string,
type: 'text' | 'password' | 'number',
initialValue: string,
help?: string
): { row: HTMLElement; input: HTMLInputElement } {
const row = document.createElement('div');
row.className = 'field-row';
const label = document.createElement('label');
label.textContent = labelText;
const field = document.createElement('div');
field.className = 'field';
const input = document.createElement('input');
input.type = type;
input.value = initialValue;
if (type === 'number') {
input.min = '0';
}
field.appendChild(input);
if (help) {
const div = document.createElement('div');
div.className = 'help';
div.textContent = help;
field.appendChild(div);
}
row.appendChild(label);
row.appendChild(field);
return { row, input };
}
// --------------------------------------------------------------------
// vista de [autenticación]
// --------------------------------------------------------------------
authenticationView(error: string | undefined, callbacks: AuthenticationCallbacks): void {
this.clearMenu();
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'Please authenticate';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
const userField = this.fieldRow("User name", 'text', 'admin');
const passwordField = this.fieldRow('Password', 'password', '');
this.content.appendChild(userField.row);
this.content.appendChild(passwordField.row);
const button = document.createElement('button');
button.textContent = 'Submit';
button.addEventListener('click', () => {
callbacks.onSubmit(userField.input.value.trim(), passwordField.input.value);
});
this.content.appendChild(button);
}
// --------------------------------------------------------------------
// vista de [cálculo de impuestos]
// --------------------------------------------------------------------
calculationView(
result: Simulation | undefined,
error: string | undefined,
callbacks: CalculationCallbacks
): void {
this.showMenu([
this.menuLink('List of simulations', callbacks.onList),
this.menuLink('End of session', callbacks.onEndSession)
]);
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'Fill in the form below and then submit it';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
// fila de los botones de opción [married]
const marriedRow = document.createElement('div');
marriedRow.className = 'field-row';
const marriedLabel = document.createElement('label');
marriedLabel.textContent = 'Are you married or in a civil partnership?';
const marriedField = document.createElement('div');
marriedField.className = 'field radios';
const radioYes = document.createElement('input');
radioYes.type = 'radio';
radioYes.name = 'married';
radioYes.value = 'yes';
radioYes.checked = true;
const labelYes = document.createElement('label');
labelYes.appendChild(radioYes);
labelYes.appendChild(document.createTextNode(' Yes'));
const radioNo = document.createElement('input');
radioNo.type = 'radio';
radioNo.name = 'married';
radioNo.value = 'no';
const labelNo = document.createElement('label');
labelNo.appendChild(radioNo);
labelNo.appendChild(document.createTextNode(' No'));
marriedField.appendChild(labelYes);
marriedField.appendChild(labelNo);
marriedRow.appendChild(marriedLabel);
marriedRow.appendChild(marriedField);
this.content.appendChild(marriedRow);
const childrenField = this.fieldRow("Number of dependent children", 'number', '0');
this.content.appendChild(childrenField.row);
const salaryField = this.fieldRow('Annual salary', 'number', '', "Round down to the nearest euro");
this.content.appendChild(salaryField.row);
const button = document.createElement('button');
button.textContent = 'Submit';
button.addEventListener('click', () => {
const married = radioYes.checked ? 'yes' : 'no';
const children = parseInt(childrenField.input.value, 10) || 0;
const salary = parseInt(salaryField.input.value, 10) || 0;
callbacks.onSubmit(married, children, salary);
});
this.content.appendChild(button);
// resultado de la última simulación (recuadro verde), si existe
if (result) {
const box = document.createElement('div');
box.className = 'result';
const ratePercent = Math.round(result.rate * 100);
box.innerHTML =
`Tax amount: ${result.tax} euros<br>` +
`Discount: ${result.discount} euros<br>` +
`Reduction: ${result.reduction} euros<br>` +
`Surcharge: ${result.surcharge} euros<br>` +
`Tax rate: ${ratePercent} %`;
this.content.appendChild(box);
}
}
// --------------------------------------------------------------------
// vista de [lista de simulaciones]
// --------------------------------------------------------------------
listView(
simulations: Simulation[],
error: string | undefined,
callbacks: ListCallbacks
): void {
this.showMenu([
this.menuLink("Tax calculation", callbacks.onCalculation),
this.menuLink('End of session', callbacks.onEndSession)
]);
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'List of your simulations';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
if (simulations.length === 0) {
const empty = document.createElement('div');
empty.className = 'simulations-empty';
empty.textContent = 'No simulation recorded.';
this.content.appendChild(empty);
return;
}
const table = document.createElement('table');
table.className = 'simulations';
const thead = document.createElement('thead');
thead.innerHTML =
'<tr><th>#</th><th>Married</th><th>Number of children</th><th>Annual salary</th>' +
'<th>Tax amount</th><th>Surcharge</th><th>Discount</th><th>Reduction</th><th>Rate</th><th></th></tr>';
table.appendChild(thead);
const tbody = document.createElement('tbody');
simulations.forEach((simulation, number) => {
const tr = document.createElement('tr');
const ratePercent = Math.round(simulation.rate * 100);
tr.innerHTML =
`<td>${number}</td>` +
`<td>${simulation.married}</td>` +
`<td>${simulation.children}</td>` +
`<td>${simulation.salary}</td>` +
`<td>${simulation.tax}</td>` +
`<td>${simulation.surcharge}</td>` +
`<td>${simulation.discount}</td>` +
`<td>${simulation.reduction}</td>` +
`<td>${ratePercent} %</td>`;
const tdDelete = document.createElement('td');
const deleteLink = document.createElement('a');
deleteLink.className = 'delete';
deleteLink.textContent = 'Delete';
deleteLink.addEventListener('click', () => callbacks.onDelete(number));
tdDelete.appendChild(deleteLink);
tr.appendChild(tdDelete);
tbody.appendChild(tr);
});
table.appendChild(tbody);
this.content.appendChild(table);
}
}
// exportación de la clase
export default Views;
El logotipo y las interfaces de TypeScript (líneas 1 a 60):
- Líneas 16–29: LOGO_SVG es una cadena de caracteres de varias líneas (delimitada por acentos graves \ \, una “plantilla de cadena”) que contiene un pequeño dibujo vectorial genérico (SVG), usado en lugar de la imagen original del servidor PHP, que no se incluyó con el proyecto TypeScript;
- líneas 32 a 41: la interfaz Simulation describe el formato de una simulación tal como la devuelve el servidor; contiene exactamente los mismos nombres de campo que la clase PHP [Simulation.php] (married, children, salary, tax, surcharge, discount, reduction, rate);
- líneas 44 a 60: las tres interfaces Callbacks... describen, para cada vista, las funciones callback que debe proporcionar el controlador (por ejemplo, onSubmit, llamada cuando el usuario hace clic en el botón “Enviar”).
El constructor (líneas 62–94):
- línea 70: el constructor recibe el elemento HTML raíz (root, la etiqueta <div id="app"> de la plantilla); la palabra clave
privateantes del parámetro es un atajo que crea automáticamente un atributorootsin necesidad de escribirthis.root = root;; - líneas 73 a 81: construcción del banner (div.banner), con el logotipo y el título <h1>Calculate your tax</h1> ;
- líneas 83 a 90: construcción del cuerpo de la página (div.page-body), que siempre contiene dos campos, this.menu y this.content; son propiedades del objeto (líneas 64–66), almacenadas en memoria para poder vaciarlas y volver a llenarlas en cada cambio de vista;
- líneas 92 y 93: por último, el encabezado y el cuerpo se agregan a la raíz de la página.
Métodos de utilidad privados (líneas 96–159):
- clearMenu (líneas 100–104): oculta la columna del menú y agrega la clase CSS full-width al área de contenido; la usa la vista de autenticación, que no tiene menú;
- menuLink (líneas 106–111): crea un enlace <a> con su texto y su función callback de clic; es un pequeño método de fábrica reutilizado para construir cada enlace del menú (“Lista de simulaciones”, “Fin de sesión”, etc.);
- showMenu (líneas 113–118): muestra la columna del menú y coloca en ella los enlaces recibidos como parámetros (un arreglo de enlaces ya construidos con menuLink);
- errorBanner (líneas 120–128): crea el recuadro rojo de error (clase CSS error) si se proporciona un mensaje de error, o no devuelve nada (null) en caso contrario;
- fieldRow (líneas 130–159): la fábrica más usada del archivo; construye una línea de formulario completa (etiqueta + campo de entrada, con texto de ayuda opcional) y devuelve tanto la línea completa (line) como el campo de entrada solo (input), de modo que quien llama pueda leer después el valor ingresado por el usuario.
El método authenticationView (líneas 161–189):
- líneas 165 y 166: la vista siempre comienza vaciando el menú y el contenido de la vista anterior;
- líneas 168 a 171: el recuadro azul “Autentíquese”;
- líneas 173 a 176: el banner de error, que se muestra solo si
errorno está vacío (es decir, solo después de un intento de autenticación fallido); - líneas 178 a 181: los dos campos del formulario, construidos con fieldRow;
- líneas 183 a 188: el botón “Enviar”; su manejador de clic (líneas 185 a 187) llama a callbacks.onSubmit(...) con el contenido de los dos campos de entrada; eso es todo lo que hace esta clase: no valida ni envía nada por sí misma, simplemente transmite lo que el usuario escribió.
El método calculationView (líneas 191–276):
- líneas 199 a 202: a diferencia de la vista anterior, esta muestra un menú con los enlaces “Lista de simulaciones” y “Fin de sesión”;
- líneas 217 a 245: creación de los dos botones de opción “Sí”/“No” (“¿Es usted casado(a) o vive en unión civil?”); es un poco más largo que los demás campos porque los botones de opción no tienen un generador genérico como fieldRow;
- líneas 247 a 251: los campos “Número de hijos a cargo” y “Salario anual”, que se construyen con fieldRow;
- líneas 253 a 261: el botón “Enviar”; su manejador de clic lee el estado de los botones de opción y el contenido de los dos campos numéricos (mediante parseInt, ya que el valor de un campo HTML siempre es una cadena), y luego llama a callbacks.onSubmit(married, children, salary);
- líneas 264 a 275: si se ha devuelto un result (es decir, tras un cálculo exitoso), se crea el recuadro verde y se llena con los cinco datos de la simulación; result.rate es un número entre 0 y 1 (por ejemplo, 0.14) que la línea 267 convierte en un porcentaje redondeado (14) para mostrarlo.
El método listView (líneas 278–344):
- líneas 286 a 289: el menú de esta vista ofrece “Cálculo del impuesto” (para volver) y “Fin de sesión”;
- líneas 303 a 309: caso especial en que la lista está vacía: se muestra un mensaje simple (“No hay simulaciones registradas.”) y el método termina allí (return), sin construir una tabla;
- líneas 311 a 317: construcción del encabezado de la tabla (<thead>), con una columna por cada campo de una simulación, más una última columna vacía para el enlace “Eliminar”;
- líneas 319 a 341: se construye una fila de la tabla (<tr>) para cada simulación, mediante simulations.forEach(...) ; el segundo parámetro de esta función, “number”, es automáticamente el índice (a partir de 0) de la simulación en la tabla, que es exactamente el número que espera la acción del servidor “delete-simulation”;
- líneas 333 a 339: el enlace “Eliminar” de cada fila; su manejador de clic (línea 337) llama a callbacks.onDelete(number) con el número de la fila correspondiente.
6.5.1.5. El controlador: el archivo [AppHtml.ts]
Este es el orquestador de la aplicación: asume el papel que cumplía la función main() de **[main3.ts], pero en forma de clase, con un método por vista. Ahora coordina dos capas, [dao] (el servidor) y [business] (el cálculo), antes de indicarle a la capa [views]** que muestre un resultado o un mensaje de error:
// importaciones
import axios from 'axios';
import "core-js/stable";
import "regenerator-runtime/runtime";
// importaciones
import Dao from './Dao3';
import Business from './Business';
import Views, { Simulation } from './Views';
// -----------------------------------------------------------------------
// controlador de la aplicación HTML: orquesta las llamadas al servidor
// (capa [dao]), los cálculos (capa [business]) y la visualización de las vistas
// (capa [views]).
//
// Al igual que [main3.ts], este cliente solo llama al servidor PHP para tres
// acciones: [init-session], [authenticate-user] y [get-admindata].
// Una vez obtenidos los datos fiscales (tasas, umbrales...) con
// [get-admindata], es la capa [business] (clase [Business], el mismo
// archivo [Business.ts] que [main3.ts]) la que calcula el impuesto en el
// navegador, sin ninguna nueva llamada de red. La lista de simulaciones también
// se mantiene solo en el navegador (arreglo [this.simulations]),
// exactamente como [main3.ts] con su arreglo local [simulations]
// (véase `simulations.push(...)` y `simulations.splice(...)`).
// -----------------------------------------------------------------------
class AppHtml {
private dao: Dao;
private views: Views;
// capa [business]: solo existe una vez recuperados los datos de impuestos
// (después de una autenticación exitosa) - ver [initBusiness]
private business?: Business;
// lista de las simulaciones ya calculadas, mantenida en el navegador
private simulations: Simulation[] = [];
constructor() {
// configuración de axios - idéntica a [main3.ts]
axios.defaults.timeout = 5000;
axios.defaults.baseURL = 'http://localhost/';
axios.defaults.withCredentials = true;
// capas [dao] y [views]
this.dao = new Dao(axios);
this.views = new Views(document.getElementById('app')!);
}
// punto de entrada de la aplicación
async start(): Promise<void> {
try {
// inicio de sesión - obligatorio antes de cualquier otra acción (ver [main.php])
const response = await this.dao.initSession();
if (response.status !== 700) {
this.views.authenticationView(this.formatError(response.response), {
onSubmit: (user, password) => this.authenticate(user, password)
});
return;
}
} catch (error: any) {
this.views.authenticationView(
"Unable to contact the server (" + error.message + ")",
{ onSubmit: (user, password) => this.authenticate(user, password) }
);
return;
}
// sesión inicializada: se muestra la autenticación
this.showAuthentication();
}
// --------------------------------------------------------------------
// vista de [autenticación]
// --------------------------------------------------------------------
private showAuthentication(error?: string): void {
this.views.authenticationView(error, {
onSubmit: (user, password) => this.authenticate(user, password)
});
}
private async authenticate(user: string, password: string): Promise<void> {
try {
const response = await this.dao.authenticateUser(user, password);
if (response.status === 200) {
// autenticación exitosa: como en [main3.ts], ahora se recuperan,
// de una vez por todas, los datos de impuestos
// que necesita la capa [business]
await this.initBusiness();
} else {
// fallo (login/contraseña incorrectos, o parámetros faltantes)
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// recupera los datos de la administración tributaria e instancia la
// capa [business] con estos datos - una sola llamada al servidor para toda la sesión,
// exactamente como [main3.ts]
private async initBusiness(): Promise<void> {
try {
const response = await this.dao.getAdminData();
if (response.status === 1000) {
this.business = new Business(response.response);
// nueva sesión de trabajo: se vuelve a empezar desde una lista vacía
this.simulations = [];
this.showCalculation();
} else {
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// --------------------------------------------------------------------
// vista de [cálculo de impuestos]
// --------------------------------------------------------------------
private showCalculation(result?: Simulation, error?: string): void {
this.views.calculationView(result, error, {
onSubmit: (married, children, salary) => this.calculate(married, children, salary),
onList: () => this.showList(),
onEndSession: () => this.endSession()
});
}
// cálculo del impuesto realizado íntegramente en el navegador (capa [business]):
// sin llamada al servidor, a diferencia de la primera versión de este cliente
private calculate(married: string, children: number, salary: number): void {
// this.business ha sido necesariamente inicializado: solo se llega a la
// vista de [cálculo] después de [initBusiness]
const result = this.business!.calculateTax(married, children, salary);
// el resultado devuelto por [business.calculateTax] solo contiene los valores
// calculados (tax, surcharge, discount, reduction, rate): se le agregan los parámetros
// ingresados por el usuario, para que puedan
// mostrarse de nuevo en la lista de simulaciones
const simulation: Simulation = { married: married, children: children, salary: salary, ...result };
// almacenamiento en el navegador (como `simulations.push(...)` en [main3.ts])
this.simulations.push(simulation);
this.showCalculation(simulation);
}
// --------------------------------------------------------------------
// vista de [lista de simulaciones]
// --------------------------------------------------------------------
// ya no hay llamadas al servidor aquí: la lista ya está íntegramente en
// [this.simulations]
private showList(error?: string): void {
this.views.listView(this.simulations, error, {
onDelete: (number) => this.deleteSimulation(number),
onCalculation: () => this.showCalculation(),
onEndSession: () => this.endSession()
});
}
private deleteSimulation(number: number): void {
// eliminación local del arreglo [this.simulations], como
// `simulations.splice(1, 1)` en [main3.ts] - tampoco hay llamada al servidor
this.simulations.splice(number, 1);
this.showList();
}
// --------------------------------------------------------------------
// fin de sesión
// --------------------------------------------------------------------
private endSession(): void {
// fin de sesión solo en el lado del cliente: se olvida la capa [business]
// (y por tanto los datos de impuestos) y las simulaciones ya calculadas, y luego se
// vuelve a la pantalla de autenticación. Este cliente no necesita
// llamar al servidor para esto.
this.business = undefined;
this.simulations = [];
this.showAuthentication();
}
// --------------------------------------------------------------------
// da formato al campo [response] de una respuesta de error del servidor,
// que es una cadena o un arreglo de cadenas (ver los controladores PHP)
// --------------------------------------------------------------------
private formatError(response: unknown): string {
if (Array.isArray(response)) {
return response.join(' ; ');
}
return String(response);
}
}
// ejecución
window.addEventListener('DOMContentLoaded', () => {
new AppHtml().start();
});
El comentario de encabezado (líneas 11–25):
- Resume toda la filosofía de este controlador, como se explicó antes: solo se usan tres acciones del servidor; el cálculo lo realiza la capa [business] en el navegador; y la lista de simulaciones es un simple arreglo almacenado del lado del cliente. Un comentario como este, al inicio del archivo, es un buen hábito que conviene adoptar: da de inmediato al lector una visión de conjunto antes de que se sumerja en los detalles del código.
Los campos de la clase y el constructor (líneas 26–44):
- líneas 28 y 29: DAO y views, ya presentes en la primera versión de este cliente;
- líneas 30–32: nuevo campo business, de tipo Business; el signo de interrogación (?) lo convierte en un campo opcional: mientras el usuario no se haya autenticado, esta propiedad aún no tiene valor (es undefined);
- líneas 33 y 34: nuevo campo “simulations”; el arreglo (inicialmente vacío, = []) reemplaza a las antiguas llamadas al servidor “list-simulations” y “delete-simulation”;
- líneas 38 a 40: configuración de [axios], idéntica a la de [main3.ts]; en particular, withCredentials = true, que es indispensable para que la cookie de sesión se envíe con cada solicitud;
- líneas 42 y 43: instanciación de las capas [dao] y [views] , sin cambios respecto a antes.
El punto de entrada, **start (líneas 47 a 66):**
- Línea 50: lo primero que hace la aplicación es llamar a
init-session, que es obligatorio antes de cualquier otra acción (véase el archivo PHP [main.php], que bloquea cualquier acción hasta que se haya inicializado una sesión); - líneas 51 a 56: en caso de fallo (estado distinto de 700), se muestra de todos modos la vista de autenticación, junto con el mensaje de error devuelto por el servidor;
- líneas 57 a 63: el bloque
catchmaneja el caso en que el servidor es totalmente inaccesible (servidor caído, URL no válida, etc.); es un error de red, distinto de una simple respuesta de error del servidor; - Línea 65: si todo salió bien, finalmente se muestra la vista de autenticación sin mensaje de error; en esta etapa, este método sigue siendo idéntico al de la versión anterior.
La vista de autenticación y la inicialización de la capa [business] (líneas 71–111):
- showAuthentication (líneas 71–75): sin cambios; simplemente le indica a la capa [views] que muestre esta vista, usando el método
authenticatecomo callback mediante onSubmit; - authenticate (líneas 77–92): llama a dao.authenticateUser(user, password); si el estado es 200, ya no se muestra directamente la vista de cálculo como antes; en su lugar, ahora se llama a this.initBusiness() (línea 84), un método nuevo; en caso de fallo, la vista de autenticación se vuelve a mostrar con el mensaje de error (línea 87), sin cambios;
- initBusiness (líneas 97–111), un método nuevo: llama a dao.getAdminData(); es el único lugar de todo el archivo donde se solicita esta acción al servidor, una vez por todas; si el estado es 1000, crea el objeto Business con los datos recibidos (línea 101, new Business(response.response)), reinicia el arreglo de simulaciones (línea 103; una nueva autenticación corresponde a una nueva sesión de trabajo) y, por último, muestra la vista de cálculo (línea 104).
La vista de cálculo del impuesto (líneas 116–138):
- showCalculation (líneas 116–122): sin cambios; se puede llamar con o sin un resultado: sin resultado para un formulario vacío (primera visita o regreso desde la lista), con resultado inmediatamente después de un cálculo exitoso;
- calculate (líneas 126–138): es el método que más ha cambiado. Ya no es asíncrono y ya no contiene un bloque de red try/catch, puesto que ya no realiza ninguna llamada al servidor; en la línea 129, this.business!.calculateTax(married, children, salary) calcula directamente el resultado; el signo de exclamación (!) le indica a TypeScript que estamos seguros de que
businessya fue inicializado (solo se puede llegar a esta vista después de initBusiness); en las líneas 130 a 134, como este resultado no contiene los parámetros ingresados, se le agregan mediante el operador de propagación ...result para construir el objeto simulation completo; en la línea 136, this.simulations.push(simulation) almacena esta nueva simulación en el arreglo del navegador; en la línea 137, la vista se vuelve a dibujar finalmente con este resultado.
La vista de lista de simulaciones (líneas 145 a 158):
- showList (líneas 145–151): ya no realiza llamadas al servidor; pasa directamente this.simulations, el arreglo que ya está en memoria, a la capa [views];
- deleteSimulation (líneas 153–158): en la línea 156, this.simulations.splice(number, 1) extrae la simulación directamente del arreglo del navegador, el equivalente exacto de la instrucción simulations.splice(1, 1) en [main3.ts]; luego, en la línea 157, se vuelve a mostrar la lista (actualizada).
Fin de sesión y punto de entrada (líneas 163–189):
- endSession (líneas 163–171): ya no llama a dao.endSession() (este método se eliminó de [Dao3.ts]); simplemente descarta la capa [business] (línea 168, this.business = undefined) y las simulaciones (línea 169, this.simulations = []), y luego vuelve a mostrar la pantalla de autenticación (línea 170); como el resto de este cliente, finalizar la sesión ya no requiere, por lo tanto, ninguna solicitud de red;
- formatError (líneas 177–182): sin cambios; el campo response de un error del servidor (PHP) es a veces una cadena y a veces un arreglo de cadenas (según el controlador); este método siempre reduce el mensaje a una sola cadena, lista para mostrarse;
- Líneas 186–188: el punto de entrada del script, fuera de la clase, permanece sin cambios; DOMContentLoaded garantiza que la página HTML esté completamente cargada antes de crear el controlador y llamar a start(); es el equivalente, para este cliente gráfico, de la llamada
main();al final de [main3.ts].
6.5.1.6. Compilación y ejecución
La compilación y la ejecución se realizan exactamente como en la sección anterior ([npm run build] o [npm start]): solo ha cambiado el punto de entrada en [webpack.config.js]. Estas son las tres pantallas obtenidas, para comparar con las capturas del documento [web_application_views.odt] proporcionado al principio:

Pantalla de autenticación: el nombre de usuario aparece rellenado previamente con “admin” por comodidad; si la autenticación falla, aquí aparece un mensaje de error, encima del formulario.

Pantalla de cálculo del impuesto, tras enviar el primer formulario: el recuadro verde muestra el resultado calculado en el navegador por la capa [business] (tax, discount, reduction, surcharge, rate, convertido aquí en porcentaje).

Pantalla “Lista de sus simulaciones”, a la que se accede haciendo clic en el enlace “Lista de simulaciones”: cada fila corresponde a una simulación almacenada en la tabla [this.simulations] del navegador, junto con su enlace “Eliminar”.
Las cinco vistas son las siguientes: autenticación, cálculo con resultados, lista de simulaciones, eliminación de una simulación (que vuelve a mostrar la lista actualizada) y fin de sesión (que regresa a la pantalla de autenticación), todo ello sin realizar nunca solicitudes al servidor PHP más allá de las tres acciones: init-session, authenticate-user, y get-admindata.
6.6. Conclusión
Este capítulo ha mostrado cómo una misma base de lógica de negocio (las capas DAO y business ) puede ejecutarse tanto desde la línea de comandos (node.js, capítulos “Client HTTP 1” y “Client HTTP 2”) como en un navegador (capítulo “Client HTTP 3”), mediante una herramienta de compilación adecuada; en este caso, webpack y ts-loader. Esta base TypeScript es el punto de partida de los frameworks front-end modernos (React, Vue, Angular...), que se construyen sobre los mismos bloques: módulos, clases, async/await y una herramienta de compilación que los ensambla para el navegador.











