6. HTTP-Clients des Steuerberechnungs-Service

6.1. Einführung
In diesem Abschnitt schreiben wir einen [node.js]-Client für den Steuerberechnungs-Service, der im Kapitel „Installation eines NestJS-Servers“ eingerichtet wurde. Die Client-Server-Architektur sieht wie folgt aus:

Wir untersuchen zwei Versionen des Clients:
- Version 1 des Clients hat folgenden Schichtenaufbau: [main, dao]:

- Version 2 des Clients hat die Struktur [main, business, dao]. Die Server-Schicht [business] wird auf den Client ausgelagert:

6.2. HTTP-Client 1

Wie erwähnt, implementiert der HTTP-Client 1 die folgende Client-Server-Architektur:

Wir implementieren:
- die [dao]-Schicht als Klasse;
- die [main]-Schicht als Skript, das diese Klasse verwendet;
6.2.1. Die [dao]-Schicht
Die [dao]-Schicht wird durch die folgende Klasse implementiert, [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 | |
- Hier wenden wir an, was wir im Kapitel über die HTTP-Funktionen von TypeScript gelernt haben;
- Zeilen 14–20: der Konstruktor der Klasse. Diese Klasse hat drei Eigenschaften:
- [axios]: das Objekt [axios], das für die HTTP-Anfragen verwendet wird. Es wird vom aufrufenden Code übergeben;
- [sessionCookieName]: Je nach Server kann das Sitzungs-Cookie unterschiedliche Namen haben. Hier lautet er [PHPSESSID];
- [sessionCookie]: das vom Server gesendete und vom Client gespeicherte Sitzungs-Cookie;
- Zeilen 62–85: Die asynchrone Funktion [calculateTax] stellt die Anfrage [post /main.php?action=calculate-tax] und sendet dabei die Parameter [married, children, salary]. Sie gibt den vom Server übermittelten JSON-String als JavaScript-Objekt zurück;
- Zeilen 88–102: Die asynchrone Funktion [listSimulations] stellt die Anfrage [get /main.php?action=list-simulations]. Sie gibt den vom Server gesendeten JSON-String als JavaScript-Objekt zurück;
- Zeilen 105–120: Die asynchrone Funktion [deleteSimulation] stellt die Anfrage [get /main.php?action=delete-simulation&number=index]. Sie gibt den vom Server gesendeten JSON-String als JavaScript-Objekt zurück;
- Zeile 132: die Schreibweise [this.axios] wird verwendet, weil hier das an den Konstruktor übergebene [axios]-Objekt in der Eigenschaft [this.axios] gespeichert wurde (Zeile 9);
- Zeile 172: Die Klasse [Dao1] wird exportiert, damit sie verwendet werden kann;
6.2.2. Das Skript [main1]
Dieses Skript verkettet eine Reihe von Aufrufen an den Server über die Klasse Dao1: Sitzungsinitialisierung, Authentifizierung, drei Steuerberechnungen (parallel), eine Liste der Simulationen und das Löschen einer davon:
Kommentare
- Zeile 3: Die Bibliothek [axios] wird importiert;
- Zeile 5: importiert die Klasse [Dao];
- Zeile 9: Die Funktion [main], die mit dem Server kommuniziert, ist asynchron;
- Zeilen 11–12: Standardkonfiguration der HTTP-Anfragen, die an den Server gesendet werden:
- Zeile 9: [timeout] mit einem Timeout von 2 Sekunden;
- Zeile 10: Allen URL-Anfragen wird die Basis-URL des Steuerberechnungsservers (http://localhost:3000) vorangestellt;
- Zeile 14 : die [Dao]-Schicht wird aufgebaut. Sie kann nun verwendet werden;
- Zeilen 48–50: Die Funktion [log] dient dazu, den JSON-String eines JavaScript-Objekts formatiert anzuzeigen: vertikal mit einer Einrückung von zwei Leerzeichen (3. Parameter);
- Zeilen 17–20: Initialisierung der JSON-Sitzung;
- Zeilen 21–24: Authentifizierung;
- Zeilen 25–32: Drei Steuerberechnungen werden parallel angefordert. Dank [await Promise.all] wird die Ausführung blockiert, bis alle drei Ergebnisse vorliegen;
- Zeilen 33–36: Liste der Simulationen;
- Zeilen 37–40: Löschen einer Simulation;
- Zeilen 41–44: Behandlung etwaiger Exceptions;
Die Ergebnisse der Ausführung lauten wie folgt:
Ausführungsergebnis:
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. HTTP-Client 2

Die Architektur des HTTP-Clients 2 sieht wie folgt aus:

Die [business]-Schicht wurde vom Server in den JavaScript-Client verlagert. Hier muss die [main]-Schicht nicht mehr die [business]-Schicht durchlaufen, um die [dao]-Schicht zu erreichen. Wir nutzen diese beiden Schichten als Kompetenzzentren:
- die [main]-Schicht greift über die [dao]-Schicht zu, wann immer sie Daten benötigt, die auf dem Server liegen;
- die [main]-Schicht fordert die [business]-Schicht auf, die Steuerberechnungen durchzuführen;
- Die [business]-Schicht ist unabhängig von der [dao]-Schicht und ruft sie nie auf;
6.3.1. Die Klasse [Business]
Die Logik der Steuerberechnung entspricht eng der der PHP-Klasse aus dem Kurs „Einführung in die Sprache PHP7 anhand von Beispielen“ – wir gehen hier nicht erneut darauf ein; uns interessiert nur ihre Übersetzung in 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 | |
- Zeile 8: taxAdminData: any – die genaue Struktur der vom Steuerserver gesendeten Daten (Sätze, Schwellenwerte usw.) ist nicht dokumentiert; wir bleiben daher bei diesem Typ bewusst flexibel, statt über eine unsichere Schnittstelle zu spekulieren;
- Die Klasse [Business] wird in Zeile 191 exportiert;
6.3.2. Die Klasse [Dao2]

Die Klasse [Dao2] implementiert die [dao]-Schicht des obigen JavaScript-Clients wie folgt:
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 | |
Kommentare
- Die Klasse [Dao2] implementiert nur drei der möglichen Anfragen an den Steuerberechnungsserver:
- [init-session] (Zeilen 21–35): zum Initialisieren der JSON-Sitzung;
- [authenticate-user] (Zeilen 37–57): zur Authentifizierung;
- [get-admindata] (Zeilen 59–73): zum Abrufen der Daten der Steuerbehörde, die es ermöglichen, die Steuerberechnungen auf der Client-Seite durchzuführen;
Wir verwenden nun Postman (siehe Abschnitt „Postman-Tests“), um die Funktionsweise der Aktion [get-admindata] zu demonstrieren. Falls noch nicht geschehen, importieren Sie (Ctrl-O) die Collection der HTTP-Anfragen – abgelegt in der Datei [tax-servers-tests.postman_collection.json] im Ordner [php_server] – in Postman:
![]() | ![]() |
Führen Sie dann die drei oben aufgeführten Anfragen [2-4] der Reihe nach aus.
Die Anfrage [4] lautet wie folgt:
![]() |
Das Ergebnis dieser Anfrage lautet wie folgt:
Der Inhalt der beiden Datenbanktabellen liegt in Form von JSON vor.
6.3.3. Das Skript [main2]

Dieses Skript initialisiert die Sitzung, authentifiziert sich, ruft die Steuerdaten ab und führt die Steuerberechnungen dann lokal über die business-Schicht aus – diese Berechnungen beziehen den Server nicht mehr ein:
- Zeile 30: taxAdminData = response.response – die Steuerdaten, die nur einmal vom Server empfangen werden, werden anschließend lokal für alle Berechnungen wiederverwendet;
- Zeile 39: const business = new Business(taxAdminData) – die Geschäftsschicht wird mit diesen Daten instanziiert, ohne je wieder eine Netzwerkanfrage zu stellen;
- Zeilen 44–46: Die drei Steuerberechnungen sind nun synchron und werden direkt im Browser oder in node.js ausgeführt, ohne den Server zu durchlaufen.
Ausführungsergebnis:
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. HTTP-Client 3
![]() |
In diesem Abschnitt führen wir [HTTP client 2] als Anwendung in einem Browser aus, gemäß der folgenden Architektur:

Während [node.js] TypeScript über tsx nativ ausführt, gilt das für Browser nicht: Es ist ein Werkzeug erforderlich, das TypeScript in JavaScript kompiliert und das Ganze anschließend zusammenfügt zu einer einzigen Datei, die von einer HTML-Seite verwendet werden kann. Das ist die Aufgabe von [webpack].
Hinweis: Der oben beschriebene Vorgang [1] ist eine HTTP-Anfrage, die vom JavaScript-Code einer HTML-Seite erzeugt wird. Wir werden gleich sehen, dass diese HTML-Seite über die URL [http://localhost:8080] (oder 8081) bezogen wird, die an einen internen, von [webpack] gestarteten Server gerichtet ist. Der Steuerberechnungsserver hingegen ist eine NestJS-Anwendung, die unter der URL [http://localhost:3000] erreichbar ist (siehe Installation eines NestJS-Servers). Wir haben hier also zwei Webanwendungen, die miteinander kommunizieren und beide über [http://localhost] angesprochen werden, jedoch nicht über denselben Port. Man sagt, sie befinden sich in unterschiedlichen Domänen. Diese Art von Anfragen zwischen zwei Webanwendungen in unterschiedlichen Domänen wird kontrolliert. Standardmäßig lehnt der NestJS-Server Anfragen eines Web-Clients ab, wenn der Client nicht denselben Ursprung wie der Server hat, d. h. [http://localhost:3000]. Es ist jedoch möglich, den NestJS-Server so zu konfigurieren, dass er diese sogenannten „Cross-Domain“-Anfragen akzeptiert. Das ist hier geschehen. Deshalb funktioniert der unten gezeigte JavaScript-Client. Die Konfiguration des NestJS-Servers können Sie im Kapitel „Fallstudie: Der Steuerberechnungsserver in NestJS“ einsehen; dort wird gezeigt, wie er so konfiguriert wird, dass er Cross-Domain-Anfragen akzeptiert.
6.4.1. Änderungen an den Werkzeugen seit 2019
Das Originaldokument (2019) verwendete [babel-loader] , um den ES6-Code in ES5 zu transpilieren, der mit älteren Browsern kompatibel ist. Da unser Projekt nun in TypeScript geschrieben ist, ersetzen wir babel-loader durch [ts-loader], der die TypeScript-Syntax (Typen, Interfaces usw.) nativ unterstützt – etwas, das Babel völlig ignoriert.
Die Datei [webpack.config.js] des Projekts (Ordner tax client/http client 3) konfiguriert das Modul [webpack]:
- Zeile 36: entry: "./src/index.ts" – Webpack beginnt mit dieser Datei und folgt allen ihren Imports, um das endgültige Bundle zu erstellen;
- Zeilen 42–44: resolve: { extensions: [".ts", ".js"] } – weist Webpack an, auch .ts-Dateien aufzulösen, selbst wenn die Endung in den Imports nicht angegeben ist;
- Zeilen 48–56: die Regel, die jede .ts-Datei im Ordner src dem Loader [ts-loader] zuordnet – dies ist der direkte Ersatz für babel-loader , der oben erwähnt wurde.
Der Inhalt der Datei [./src/index.ts] lautet wie folgt:
Beachten Sie, dass der JavaScript-Code in einem Browser ausgeführt wird. Die vorherige Zeile wird daher nicht in ein Terminal, sondern in die Konsole des Browsers geschrieben, der diesen Code ausführt.
Die Datei [package.json] in diesem Unterprojekt sieht wie folgt aus. Sie hat eigene Skripte und Abhängigkeiten (ts-loader, TypeScript sowie core-js und regenerator-runtime, bei denen es sich um Polyfills handelt, die die Kompatibilität mit älteren Browsern sicherstellen):
- Zeilen 12–20: Abhängigkeiten, die während der Entwicklung des Projekts (Kompilierung) benötigt werden;
-
Zeilen 21–26: Abhängigkeiten, die bei der Ausführung des Projekts benötigt werden;
-
Zeile 17: [webpack]: der Orchestrator. [webpack] führt die Transpilation des TypeScript-Codes nach ES5 durch und fasst dann alle resultierenden Dateien zu einer einzigen Datei zusammen;
- Zeile 18: [webpack-cli]: wird benötigt von [webpack];
- Zeile 13: [@webpack-cli/init]: dient zur Konfiguration von [webpack];
- Zeile 19: [webpack-dev-server]: stellt einen Entwicklungs-Webserver bereit, der standardmäßig auf Port 8080 oder 8081 läuft. Wenn die Quelldateien geändert werden, lädt [webpack-dev-server] die Webanwendung automatisch neu;
6.4.2. Das Projekt kompilieren und ausführen
Die Datei [package.json] definiert drei Aufgaben, [npm]:
Diese Aufgaben werden von [VSCode] erkannt, das sie zur Ausführung anbietet. Bewegen Sie die Maus über die Aufgabe „build“ in Zeile 3:
![]() |
Klicken Sie einfach auf [Run Script], um die ausgewählte Aufgabe auszuführen. Sie können auch den folgenden Befehl eingeben:
in einem Terminal, das sich im Ordner mit der Datei [package.json] befindet.
Die Aufgabe [build] erstellt im Projekt VSCode einen Ordner namens [dist] (1):
![]() |
- In [3]: das Projekt wird nach [dist/main.hash.js] kompiliert, und eine Seite namens [dist/index.html] wird erstellt (2);
Die erzeugte Seite [index.html] sieht wie folgt aus:
Diese Seite bindet also lediglich die [main.hash.js]-Datei ein, die von [webpack] erzeugt wurde.
Das Projekt wird durch die Aufgabe [start] ausgeführt:
Die Seite [dist/index.html] wird dann auf einen Server geladen, der zur [webpack] -Suite gehört und auf Port 8080 oder 8081 des lokalen Rechners läuft, und im Standardbrowser des Rechners angezeigt:
![]() |
- in [2], der Port des [webpack]-Webservers;
- in [3-4] der Reiter [console] in den Entwicklertools des Browsers, hier Microsoft Edge (aufrufbar mit F12);
- in [5] das Ergebnis der Ausführung der Datei [src/index.ts]. Zur Erinnerung: Der Inhalt dieser Datei lautete wie folgt:
Ändern wir nun diesen Inhalt in die folgende Zeile in [index.ts]:
und speichern Sie die Datei. Automatisch (ohne erneutes Kompilieren) wird eine neue Datei namens [index.html] erzeugt, und diese neue Datei [index.html] wird in den Browser geladen:
![]() |
Es ist nicht nötig, die Aufgabe [build] vor der Aufgabe [start] auszuführen: Letztere kompiliert das Projekt zuerst. Sie speichert die Ausgabe dieser Kompilierung nicht im Ordner [dist]. Um dies zu überprüfen, löschen Sie einfach diesen Ordner. Sie werden dann sehen, dass die Aufgabe [start] das Projekt kompiliert und ausführt, ohne den Ordner [dist] zu erstellen. Sie scheint ihre Ausgabe [index.html, main.hash.js] in einem Ordner abzulegen, der spezifisch für [webpack-dev-server] ist. Dieses Verhalten genügt für unsere Tests.
Solange der Entwicklungsserver läuft, löst jede gespeicherte Änderung an einer der Projektdateien eine Neukompilierung aus. Aus diesem Grund deaktivieren wir den Modus [Auto Save] von [VSCode]. Wir wollen nämlich nicht, dass bei jeder Eingabe von Zeichen in einer der Projektdateien eine Neukompilierung erfolgt. Eine Neukompilierung soll nur erfolgen, wenn Änderungen gespeichert werden:

- In [2] darf die Option [Auto Save] nicht aktiviert sein;
6.4.3. Test des JavaScript-Web-Clients für den Steuerberechnungsserver
Um den JavaScript-Webclient für den Steuerberechnungsserver zu testen, müssen Sie [main3.ts] [1] als Einstiegspunkt des Projekts in der Datei [webpack.config.js] [2-3] angeben:
![]() | ![]() |
- In [1] das Skript [main3.ts];
- in [2-3] der Eintrag [entry], der in der Konfigurationsdatei von [webpack] zu ändern ist;
6.4.3.1. Das Skript [main3]
Dieses Skript verwendet den Inhalt von main2.ts (vorheriges Kapitel), angepasst für einen Browser (Import von Polyfills):
- Zeilen 3–4: import "core-js/stable" und import "regenerator-runtime/runtime" – die Polyfills, die benötigt werden, damit der kompilierte Code in Browsern funktioniert, die noch nicht alle neuesten Sprachfunktionen nativ implementieren;
- Zeile 15: axios.defaults.withCredentials = true – in einem Browser unerlässlich, damit Sitzungs-Cookies automatisch zwischen Anfragen weitergegeben werden, was der Code in den früheren Versionen manuell erledigte (node.js unterstützt keine Browser-Cookies).
6.4.3.2. Die Klasse [Dao3]
Da das Sitzungs-Cookie nun vom Modul [axios] verwaltet wird, können wir die Behandlung dieses Cookies aus der Klasse [Dao] entfernen:
In diesem Code gibt es keine Cookie-Behandlung mehr.
6.4.3.3. Kompilierung und Ausführung
Die Datei package.json definiert zwei npm-Aufgaben:
- [npm run build] – kompiliert das Projekt; die resultierenden Dateien werden in dist/ abgelegt (eine Datei main.<hash>.js und eine Datei index.html, die sie automatisch mithilfe des html-webpack-plugin einbindet);
- [npm start] – startet webpack-dev-server: kompiliert das Projekt und stellt es unter http://localhost:8080 bereit, mit automatischem Neuladen der Seite bei jedem Speichern einer Quelldatei.
Wir führen diese beiden Aufgaben aus. Das Ergebnis auf der Seite [console] im Browser (mit F12 aufrufen) lautet wie folgt:
![]() |
6.5. HTML-Client
![]() |
Die vorherigen Abschnitte haben den Client [http client 3] ausschließlich im Konsolenmodus verwendet: Das Skript [main3.ts] kommuniziert mit dem Server und zeigt seine Ergebnisse dann mit console.log an, ohne dass eine Seite im Browser sichtbar wäre. Wir bauen nun einen echten grafischen Client mit Bildschirmen (Authentifizierung, Steuerberechnung, Liste der Simulationen).
Wir beginnen mit dem Clientprojekt [http client 3] (dieselben Dateien wie [package.json] und [tsconfig.json]) und verwenden zwei vorhandene Dateien ohne Änderung wieder: [Dao3.ts] (Schicht [dao]) und [Business.ts] (Schicht [business], bereits im Zusammenhang mit [main3.ts] behandelt). Wir ergänzen lediglich:
- eine Datei namens [src/index.html], die als Template für die Seite dient (Header, CSS-Stile, Bereich, in dem die Views angezeigt werden);
- eine neue Datei [Views.ts], die die HTML-Elemente (Formulare, Tabelle, Fehlermeldungen) direkt in JavaScript erzeugt, ohne je selbst den Server aufzurufen;
- eine neue Datei [AppHtml.ts], der Anwendungscontroller: Er koordiniert die Schichten [dao] und [business] und weist dann die Schicht [views] an, das Ergebnis anzuzeigen;
- eine geringfügige Änderung an [webpack.config.js] , damit das Projekt diesen neuen Einstiegspunkt mit dem neuen HTML-Template kompiliert.
Das Quartett [dao] / [business] / [views] / Controller bildet somit exakt die bereits in diesem Kurs behandelte Schichtenarchitektur nach: die [dao]-Schicht für den Serverzugriff, die [business]-Schicht für die Anwendungslogik (Steuerberechnung) und das Hauptskript (hier die Klasse [AppHtml]) für die Orchestrierung. Nur die [views]-Schicht ist wirklich neu: Sie ersetzt die Konsolenausgabe durch eine Ausgabe im Browser.
6.5.1. Lösungsarchitektur
Dieser HTML-Client arbeitet exakt wie [main3.ts], und das ist eine zentrale Entwurfsentscheidung: Er ruft den (PHP-)Server nur für drei Aktionen auf, und zwar immer dieselben: init-session, authenticate-user und get-admindata. Der (PHP-)Code des Servers zeigt jedoch, dass dieser auch selbst die Steuer berechnen und die Simulationen in seiner Session speichern kann (das sind die Aktionen calculate-tax, list-simulations und delete-simulation, die sich im Ordner [Controllers] finden), doch dieser Client nutzt sie nicht.
Der Grund ist einfach: Sobald die Steuerdaten (Sätze, Schwellenwerte usw.) einmalig mit get-admindata abgerufen wurden, ist dank der Klasse [Business] bereits alles, was für die Steuerberechnung nötig ist, im Browser vorhanden. Diese Berechnung bei jeder Simulation vom Server anzufordern, würde einen vermeidbaren Netzwerk-Roundtrip erfordern; ebenso brächte es keinen Mehrwert, die Liste erneut vom Server anzufordern (list-simulations), da jede berechnete Simulation sofort im Browser gespeichert wird. Dieser Client minimiert die Serveranfragen daher so weit wie möglich – genau das Prinzip, das bereits in [main3.ts] umgesetzt ist:
- die [dao]-Schicht ([Dao3.ts]) bleibt unverändert: Ihre drei bereits oben vorgestellten Methoden (initSession, authenticateUser, getAdminData) genügen; es wird keine hinzugefügt;
- unmittelbar nach erfolgreicher Authentifizierung wird getAdminData ein für alle Mal aufgerufen, und mit dem Ergebnis wird ein Business-Objekt erzeugt (new Business(taxAdminData)), das während der gesamten Arbeitssitzung erhalten bleibt;
- jede Steuerberechnung ruft anschließend direkt business.calculateTax(married, children, salary) auf – eine gewöhnliche JavaScript-Funktion, die im Browser ohne jeden Netzwerkaufruf ausgeführt wird;
- die berechneten Simulationen werden in einem einfachen JavaScript-Array gespeichert, das der Controller im Speicher hält – ein push pro Berechnung, ein splice pro Löschung, genau wie es [main3.ts] mit den Anweisungen simulations.push(...) und simulations.splice(1, 1) tut.
Ein kleiner Unterschied zu [main3.ts]: Die Methode business.calculateTax liefert nur die von ihr berechneten Werte zurück (tax, surcharge, discount, reduction, rate), nicht die vom Benutzer eingegebenen Parameter (married, children, salary). [main3.ts] braucht sie nicht, da es einfach console.log verwendet; unsere View [Liste der Simulationen] muss diese drei Parameter jedoch in der Tabelle anzeigen – daher hängt der Controller sie vor dem Speichern selbst an das Ergebnis an (das sehen wir im Code von [AppHtml.ts]).
Schließlich ruft auch die View [Sitzungsende] den Server nicht mehr auf: Sie verwirft lediglich das [Business]-Objekt und die Liste der Simulationen und zeigt dann erneut den Authentifizierungsbildschirm an. Zur Erinnerung: Die Antworten der drei weiterhin verwendeten Serveraktionen haben immer dasselbe Format, das wir bereits in [main3.ts] gesehen haben: ein JSON-Objekt { action, status, response }, wobei response entweder das angeforderte Ergebnis (bei Erfolg) oder eine Fehlermeldung enthält – je nach zuständigem PHP-Controller ein String oder ein Array von Strings.
6.5.1.1. Das HTML-Template: die Datei [src/index.html]
Ein [webpack]-Projekt mit [html-webpack-plugin] (wie hier der Fall; siehe die Datei [webpack.config.js]) kann mit einer fertigen HTML-Seite beginnen – einem „Template“ –, in die das Plugin automatisch das <script> -Tag einfügt, das das kompilierte Bundle lädt. Bisher hatte dieses Projekt kein Template: [html-webpack-plugin] erzeugte eine minimale, leere HTML-Seite ohne Formatierung. Nun stellen wir eines bereit: die Datei [src/index.html], die Folgendes enthält:
- einen <style> -Block mit der gesamten Formatierung der Anwendung (Kopfbereich, Menü, Formulare, Tabelle, Fehler- und Ergebnismeldungen);
- ein einziges <div id="app"></div> -Tag: Es ist das einzige „sichtbare“ HTML-Element im Template – der Rest der Seite (Kopfbereich, Formulare, Tabelle usw.) wird in JavaScript dynamisch von der Klasse [Views] innerhalb dieses Tags erzeugt.
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 | |
Dies ist eine gewöhnliche HTML/CSS-Datei – hier ist nichts spezifisch für TypeScript –, aber da sich dieser Kurs an Anfänger richtet, gehen wir die wichtigsten Punkte im Detail durch:
Die CSS-Variablen (Zeilen 7–16):
- Der Block :root { --name: value; ... } deklariert CSS-Variablen (auch „Custom Properties“ genannt): --light-blue, --light-green usw.;
- diese werden im restlichen Stylesheet mit der Funktion var(...) wiederverwendet, zum Beispiel background: var(--banner-grey); in Zeile 40;
- Der Vorteil: Es genügt, die Farbe einmal am Anfang der Datei zu ändern, damit sie überall geändert ist, wo sie verwendet wird, statt jeden Farbcode in der gesamten Datei suchen zu müssen.
Die allgemeine Struktur (Zeilen 29–87):
- #app (Zeile 29) begrenzt die Breite der Anwendung und fügt einen Rahmen hinzu;
- .banner (Zeile 36) zeigt Logo und Titel mit
display: flexnebeneinander an; - .page-body (Zeile 56) teilt den Rest der Seite in zwei flexible Spalten: .menu (Zeile 61, feste Breite von 160 Pixeln) links und .content (Zeile 80, variable Breite) rechts; die Klasse .content.full-width (Zeile 85) blendet diese Menüspalte für die Login-View aus, die sie nicht benötigt.
Von der [views]-Schicht wiederverwendete Klassen (Zeilen 90–210):
- .section-title (Zeile 90): das hellblaue Feld für die Überschriften „Please authenticate“, „Fill in the form below and then submit it“ und „List of your simulations“;
- .field-row (Zeile 99): eine Formularzeile (Label + Eingabefeld);
- .result (Zeile 152): das hellgrüne Feld, das das Ergebnis einer Steuerberechnung anzeigt;
- .error (Zeile 161): das hellrote Feld, das eine vom Server zurückgegebene Fehlermeldung anzeigt;
- table.simulations (Zeile 171): die Formatierung der Tabelle in der View „Liste der Simulationen“ mit ihren blauen „Delete“-Links (Regel table.simulations a.delete, Zeile 196).
Jede dieser Klassen findet sich im Code der Klasse [Views] (className = '...' oder classList.add('...')) – diese Klasse erzeugt in JavaScript die HTML-Elemente und wendet diese CSS-Klassen auf sie an.
6.5.1.2. Die geänderte Konfiguration [webpack.config.js]
Die Datei [webpack.config.js] wurde bereits weiter oben in diesem Kapitel vollständig vorgestellt. Zwei kleine Änderungen genügen, damit sie diesen neuen grafischen Client statt des Testskripts [main3.ts] kompiliert:
- Zeile 4: entry: "./src/AppHtml.ts" ersetzt entry: "./src/main3.ts" – der neue Controller dient nun als Einstiegspunkt des Bundles; der alte Wert bleibt direkt darunter als Kommentar erhalten (Zeilen 5–8), sodass Sie bei Bedarf leicht zum Testskript zurückwechseln können;
- Zeilen 21–23: new HtmlWebpackPlugin({ template: ... }) ersetzt new HtmlWebpackPlugin() (ohne Parameter) – wir weisen es ausdrücklich an, unser Template [src/index.html] zu verwenden, statt eine leere HTML-Seite zu erzeugen.
6.5.1.3. Die Schichten [dao] und [business] : zwei Dateien, die unverändert wiederverwendet werden
Die Datei [Dao3.ts] wird hier nicht geändert: Ihre drei bereits weiter oben in diesem Kapitel vorgestellten Methoden (initSession, authenticateUser, getAdminData sowie die Hilfsmethode getRemoteData) sind genau das, was dieser grafische Client benötigt – es wird keine hinzugefügt.
[Business.ts] wird ebenfalls nicht geändert: Es ist dieselbe Klasse [Business] mit ihrer Methode calculateTax(married, children, salary), die bereits bei der Besprechung von [main3.ts] (Abschnitt [Client HTTP 2]) vollständig vorgestellt wurde. Dieser grafische Client ist jedoch der erste in diesem Kapitel, der die Ergebnisse dieser Berechnung tatsächlich auf dem Bildschirm anzeigt, statt sie nur zu protokollieren – so lässt sich überprüfen, ob die unmittelbar danach vorgestellte [views]-Schicht sie korrekt formatieren kann.
6.5.1.4. Die [views]-Schicht: die Datei [Views.ts]
Dies ist die längste Datei dieses Clients, aber auch die am leichtesten verständliche, sobald man ihr Prinzip erfasst hat: Die Klasse [Views] führt keinerlei Netzwerkaufrufe aus – sie weiß nicht einmal, dass der PHP-Server existiert. Ihr einziger Zweck ist es, mit den DOM-Funktionen (document.createElement, appendChild, classList ...) die HTML-Elemente der drei Bildschirme der Anwendung innerhalb des <div id="app"> -Tags des Templates zu erzeugen.
Wenn der Benutzer auf eine Schaltfläche oder einen Link klickt („Submit“, „Delete“, „End of session“ usw.), weiß die Klasse [Views] mit diesem Klick ebenfalls nichts anzufangen: Sie ruft lediglich eine vom Controller bereitgestellte Callback-Funktion auf – der Controller, [AppHtml.ts], der kurz darauf beschrieben wird, entscheidet dann, was zu tun ist (den Server aufrufen, die View wechseln usw.). Diese Entkopplung ermöglicht es [Views.ts] , unabhängig von der [dao]-Schicht zu bleiben.
'use strict';
// -----------------------------------------------------------------------
// Aufbau der Views (DOM) der Anwendung – nach dem Vorbild der
// Screenshots des Dokuments [web_application_views.odt]:
// - Authentifizierungs-View
// - View für die Steuerberechnung (Formular + Ergebnis)
// - View mit der Liste der Simulationen
// Dieses Modul führt keinen Netzwerkaufruf aus: Es baut das DOM auf und delegiert
// die Aktionen des Benutzers (Submit, Delete, Menülinks) an Callback-
// Funktionen, die der Controller [App] bereitstellt.
// -----------------------------------------------------------------------
// eine generische Dekoration (nicht das Foto des ursprünglichen PHP-Servers, das
// uns nicht vorliegt): bei Bedarf durch das echte Logo in [Resources/] ersetzen
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>`;
// Ergebnis einer Steuerberechnung, wie es der Server zurückgibt (siehe [Simulation.php])
export interface Simulation {
married: string;
children: number;
salary: number;
tax: number;
surcharge: number;
discount: number;
reduction: number;
rate: number;
}
// Callbacks der View [authentication]
export interface AuthenticationCallbacks {
onSubmit: (user: string, password: string) => void;
}
// Callbacks der View [calculation]
export interface CalculationCallbacks {
onSubmit: (married: string, children: number, salary: number) => void;
onList: () => void;
onEndSession: () => void;
}
// Callbacks der View [list]
export interface ListCallbacks {
onDelete: (number: number) => void;
onCalculation: () => void;
onEndSession: () => void;
}
class Views {
private banner: HTMLElement;
private menu: HTMLElement;
private content: HTMLElement;
// baut die feste Struktur der Seite (Banner + Menü-/Inhaltsbereich)
// innerhalb des Elements [root] auf
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);
}
// --------------------------------------------------------------------
// Hilfsfunktionen zum Aufbau des 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;
}
// eine Formularzeile [Label + Text-/Passwort-/Zahlenfeld]
private fieldRow(
labelText: string,
type: 'text' | 'password' | 'number',
initialValue: string,
help?: string
): { row: HTMLElement; input: HTMLInputElement } {
const row = document.createElement('div');
row.className = 'field-row';
const label = document.createElement('label');
label.textContent = labelText;
const field = document.createElement('div');
field.className = 'field';
const input = document.createElement('input');
input.type = type;
input.value = initialValue;
if (type === 'number') {
input.min = '0';
}
field.appendChild(input);
if (help) {
const div = document.createElement('div');
div.className = 'help';
div.textContent = help;
field.appendChild(div);
}
row.appendChild(label);
row.appendChild(field);
return { row, input };
}
// --------------------------------------------------------------------
// View [authentication]
// --------------------------------------------------------------------
authenticationView(error: string | undefined, callbacks: AuthenticationCallbacks): void {
this.clearMenu();
this.content.innerHTML = '';
const title = document.createElement('div');
title.className = 'section-title';
title.textContent = 'Please authenticate';
this.content.appendChild(title);
const banner = this.errorBanner(error);
if (banner) {
this.content.appendChild(banner);
}
const userField = this.fieldRow("User name", 'text', 'admin');
const passwordField = this.fieldRow('Password', 'password', '');
this.content.appendChild(userField.row);
this.content.appendChild(passwordField.row);
const button = document.createElement('button');
button.textContent = 'Submit';
button.addEventListener('click', () => {
callbacks.onSubmit(userField.input.value.trim(), passwordField.input.value);
});
this.content.appendChild(button);
}
// --------------------------------------------------------------------
// View [tax calculation]
// --------------------------------------------------------------------
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);
}
// Zeile der Radiobuttons [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);
// Ergebnis der letzten Simulation (grüner Kasten), falls vorhanden
if (result) {
const box = document.createElement('div');
box.className = 'result';
const ratePercent = Math.round(result.rate * 100);
box.innerHTML =
`Tax amount: ${result.tax} euros<br>` +
`Discount: ${result.discount} euros<br>` +
`Reduction: ${result.reduction} euros<br>` +
`Surcharge: ${result.surcharge} euros<br>` +
`Tax rate: ${ratePercent} %`;
this.content.appendChild(box);
}
}
// --------------------------------------------------------------------
// View [list of simulations]
// --------------------------------------------------------------------
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);
}
}
// Export der Klasse
export default Views;
Das Logo und die TypeScript-Schnittstellen (Zeilen 1 bis 60):
- Zeilen 16–29: LOGO_SVG ist ein mehrzeiliger String (begrenzt durch Gravis-Zeichen \ \, ein „Template String“), der eine kleine generische Vektorzeichnung (SVG) enthält; sie wird anstelle des ursprünglichen PHP-Server-Bildes verwendet, das dem TypeScript-Projekt nicht beilag;
- Zeilen 32 bis 41: Die Schnittstelle Simulation beschreibt das Format einer Simulation, wie sie der Server zurückgibt – sie enthält exakt dieselben Feldnamen wie die PHP-Klassen [Simulation.php] (married, children, salary, tax, surcharge, discount, reduction, rate);
- Zeilen 44 bis 60: Die drei Schnittstellen Callbacks... beschreiben für jede View die Callback-Funktionen, die der Controller bereitstellen muss (zum Beispiel onSubmit, das aufgerufen wird, wenn der Benutzer auf die Schaltfläche „Submit“ klickt).
Der Konstruktor (Zeilen 62–94):
- Zeile 70: Der Konstruktor erhält das HTML-Wurzelelement (root, das <div id="app"> -Tag des Templates) – das Schlüsselwort
privatevor dem Parameter ist eine Kurzschreibweise, die automatisch ein Attributrooterzeugt, ohne dassthis.root = root;geschrieben werden muss; - Zeilen 73 bis 81: Aufbau des Banners (div.banner) mit dem Logo und dem Titel <h1>Calculate your tax</h1> ;
- Zeilen 83 bis 90: Aufbau des Seitenkörpers (div.page-body), der immer zwei Felder enthält, this.menu und this.content – das sind Objekteigenschaften (Zeilen 64–66), die im Speicher gehalten werden, damit sie bei jedem View-Wechsel geleert und neu befüllt werden können;
- Zeilen 92 und 93: Kopfbereich und Körper werden schließlich zur Wurzel der Seite hinzugefügt.
Private Hilfsmethoden (Zeilen 96–159):
- clearMenu (Zeilen 100–104): blendet die Menüspalte aus und fügt dem Inhaltsbereich die CSS-Klasse full-width hinzu – wird von der Authentifizierungs-View verwendet, die kein Menü hat;
- menuLink (Zeilen 106–111): erzeugt einen <a> -Link mit seinem Text und seiner Klick-Callback-Funktion – eine kleine Fabrikmethode, die wiederverwendet wird, um jeden Menülink zu erstellen („List of simulations“, „End of session“ usw.);
- showMenu (Zeilen 113–118): zeigt die Menüspalte an und platziert die als Parameter übergebenen Links darin (ein Array von Links, die bereits mit menuLink erstellt wurden);
- errorBanner (Zeilen 120–128): erzeugt das rote Fehlerfeld (CSS-Klasse error), wenn eine Fehlermeldung übergeben wird, und gibt andernfalls nichts zurück (null);
- fieldRow (Zeilen 130–159): die am häufigsten verwendete Fabrikmethode der Datei – sie baut eine vollständige Formularzeile (Label + Eingabefeld, mit optionalem Hilfetext) und gibt sowohl die vollständige Zeile (line) als auch allein das Eingabefeld (input) zurück, damit der Aufrufer anschließend den vom Benutzer eingegebenen Wert lesen kann.
Die Methode authenticationView (Zeilen 161–189):
- Zeilen 165 und 166: Die View beginnt immer damit, das Menü und den Inhalt der vorherigen View zu leeren;
- Zeilen 168 bis 171: das blaue Feld „Please authenticate“;
- Zeilen 173 bis 176: das Fehlerbanner, das nur angezeigt wird, wenn
errornicht leer ist (also nur nach einem fehlgeschlagenen Authentifizierungsversuch); - Zeilen 178 bis 181: die beiden Formularfelder, erstellt mit fieldRow;
- Zeilen 183 bis 188: die Schaltfläche „Submit“; ihr Klick-Handler (Zeilen 185 bis 187) ruft callbacks.onSubmit(...) mit dem Inhalt der beiden Eingabefelder auf – mehr tut diese Klasse nicht: Sie validiert nichts und sendet nichts selbst, sondern reicht lediglich weiter, was der Benutzer eingegeben hat.
Die Methode calculationView (Zeilen 191–276):
- Zeilen 199 bis 202: Anders als die vorherige View zeigt diese ein Menü mit den Links „List of simulations“ und „End of session“ an;
- Zeilen 217 bis 245: Erzeugung der beiden Radiobuttons „Yes“/„No“ („Are you married or in a civil partnership?“) – etwas länger als die übrigen Felder, da es für Radiobuttons keinen generischen Generator wie fieldRow gibt;
- Zeilen 247 bis 251: die Felder „Number of dependent children“ und „Annual salary“, die mit fieldRow erstellt werden;
- Zeilen 253 bis 261: die Schaltfläche „Submit“; ihr Klick-Handler liest den Zustand der Radiobuttons und den Inhalt der beiden numerischen Felder (mit parseInt, da der Wert eines HTML-Feldes immer ein String ist) und ruft dann callbacks.onSubmit(married, children, salary) auf;
- Zeilen 264 bis 275: Wurde ein result zurückgegeben (also nach einer erfolgreichen Berechnung), wird das grüne Feld erzeugt und mit den fünf Informationen der Simulation gefüllt; result.rate ist eine Zahl zwischen 0 und 1 (zum Beispiel 0.14), die Zeile 267 für die Anzeige in einen gerundeten Prozentwert (14) umwandelt.
Die Methode listView (Zeilen 278–344):
- Zeilen 286 bis 289: Das Menü dieser View bietet „Tax calculation“ (um zurückzugehen) und „End of session“ an;
- Zeilen 303 bis 309: Sonderfall einer leeren Liste – es wird eine einfache Meldung angezeigt („No simulation recorded.“) und die Methode endet dort (return), ohne eine Tabelle aufzubauen;
- Zeilen 311 bis 317: Aufbau der Tabellenkopfzeile (<thead>) mit einer Spalte pro Feld einer Simulation sowie einer letzten leeren Spalte für den „Delete“-Link;
- Zeilen 319 bis 341: Für jede Simulation wird eine Tabellenzeile (<tr>) mit simulations.forEach(...) aufgebaut – der zweite Parameter dieser Funktion, „number“, ist automatisch der Index (ab 0) der Simulation in der Tabelle, und genau diese Nummer erwartet die Serveraktion „delete-simulation“;
- Zeilen 333 bis 339: der „Delete“-Link jeder Zeile; sein Klick-Handler (Zeile 337) ruft callbacks.onDelete(number) mit der Nummer der betreffenden Zeile auf.
6.5.1.5. Der Controller: die Datei [AppHtml.ts]
Dies ist der Orchestrator der Anwendung: Er übernimmt die Rolle der Funktion main() aus **[main3.ts], jedoch in Form einer Klasse mit einer Methode pro View. Er koordiniert nun zwei Schichten, [dao] (der Server) und [business] (die Berechnung), bevor er die [views]**-Schicht anweist, entweder ein Ergebnis oder eine Fehlermeldung anzuzeigen:
// Importe
import axios from 'axios';
import "core-js/stable";
import "regenerator-runtime/runtime";
// Importe
import Dao from './Dao3';
import Business from './Business';
import Views, { Simulation } from './Views';
// -----------------------------------------------------------------------
// Controller der HTML-Anwendung: orchestriert die Aufrufe des Servers
// (Schicht [dao]), die Berechnungen (Schicht [business]) und die Anzeige der Views
// (Schicht [views]).
//
// Wie [main3.ts] ruft dieser Client den PHP-Server nur für drei
// Aktionen auf: [init-session], [authenticate-user] und [get-admindata].
// Sobald die Steuerdaten (Sätze, Obergrenzen ...) mit
// [get-admindata] abgerufen wurden, berechnet die Schicht [business] (Klasse [Business], dieselbe
// Datei [Business.ts] wie bei [main3.ts]) die Steuer im
// Browser, ohne einen weiteren Netzwerkaufruf. Auch die Liste der Simulationen wird
// nur im Browser gehalten (Array [this.simulations]),
// genau wie [main3.ts] es mit seinem lokalen Array [simulations] tut
// (siehe `simulations.push(...)` und `simulations.splice(...)`).
// -----------------------------------------------------------------------
class AppHtml {
private dao: Dao;
private views: Views;
// [business]-Schicht: existiert erst, wenn die Steuerdaten abgerufen wurden
// (nach erfolgreicher Authentifizierung) - siehe [initBusiness]
private business?: Business;
// Liste der bereits berechneten Simulationen, im Browser gehalten
private simulations: Simulation[] = [];
constructor() {
// axios-Konfiguration - identisch mit [main3.ts]
axios.defaults.timeout = 5000;
axios.defaults.baseURL = 'http://localhost/';
axios.defaults.withCredentials = true;
// [dao]- und [views]-Schichten
this.dao = new Dao(axios);
this.views = new Views(document.getElementById('app')!);
}
// Einstiegspunkt der Anwendung
async start(): Promise<void> {
try {
// Sitzung initialisieren - zwingend vor jeder anderen Aktion (siehe [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;
}
// Sitzung initialisiert: Wir zeigen die Authentifizierung an
this.showAuthentication();
}
// --------------------------------------------------------------------
// View [authentication]
// --------------------------------------------------------------------
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) {
// erfolgreiche Authentifizierung: Wie in [main3.ts] rufen wir nun
// ein für alle Mal die Steuerdaten ab,
// die von der [business]-Schicht benötigt werden
await this.initBusiness();
} else {
// Fehlschlag (falsches Login/Passwort oder fehlende Parameter)
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// ruft die Daten der Steuerverwaltung ab und instanziiert die
// [business]-Schicht mit diesen Daten - ein einziger Serveraufruf für die gesamte Sitzung,
// genau wie [main3.ts]
private async initBusiness(): Promise<void> {
try {
const response = await this.dao.getAdminData();
if (response.status === 1000) {
this.business = new Business(response.response);
// neue Arbeitssitzung: Wir beginnen wieder mit einer leeren Liste
this.simulations = [];
this.showCalculation();
} else {
this.showAuthentication(this.formatError(response.response));
}
} catch (error: any) {
this.showAuthentication("Unable to contact the server (" + error.message + ")");
}
}
// --------------------------------------------------------------------
// View [tax calculation]
// --------------------------------------------------------------------
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()
});
}
// Steuerberechnung vollständig im Browser ([business]-Schicht):
// kein Serveraufruf, anders als in der ersten Version dieses Clients
private calculate(married: string, children: number, salary: number): void {
// this.business wurde zwangsläufig initialisiert: Wir gelangen erst nach [initBusiness]
// zur View [calculation]
const result = this.business!.calculateTax(married, children, salary);
// Das von [business.calculateTax] zurückgegebene Ergebnis enthält nur die
// berechneten Werte (tax, surcharge, discount, reduction, rate): Wir ergänzen es um die
// vom Benutzer eingegebenen Parameter, damit sie
// erneut in der Liste der Simulationen angezeigt werden können
const simulation: Simulation = { married: married, children: children, salary: salary, ...result };
// Speicherung im Browser (wie `simulations.push(...)` in [main3.ts])
this.simulations.push(simulation);
this.showCalculation(simulation);
}
// --------------------------------------------------------------------
// View [list of simulations]
// --------------------------------------------------------------------
// keine Serveraufrufe mehr hier: Die Liste befindet sich bereits vollständig in
// [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 {
// lokales Löschen aus dem Array [this.simulations], wie
// `simulations.splice(1, 1)` in [main3.ts] - weiterhin kein Serveraufruf
this.simulations.splice(number, 1);
this.showList();
}
// --------------------------------------------------------------------
// Ende der Sitzung
// --------------------------------------------------------------------
private endSession(): void {
// Ende der Sitzung nur auf der Client-Seite: Wir vergessen die [business]-Schicht
// (und damit die Steuerdaten) und die bereits berechneten Simulationen und
// kehren dann zum Authentifizierungsbildschirm zurück. Dieser Client muss dafür
// den Server nicht aufrufen.
this.business = undefined;
this.simulations = [];
this.showAuthentication();
}
// --------------------------------------------------------------------
// formatiert das Feld [response] einer Fehlerantwort des Servers,
// das entweder ein String oder ein Array von Strings ist (siehe PHP-Controller)
// --------------------------------------------------------------------
private formatError(response: unknown): string {
if (Array.isArray(response)) {
return response.join(' ; ');
}
return String(response);
}
}
// Ausführung
window.addEventListener('DOMContentLoaded', () => {
new AppHtml().start();
});
Der Kommentar im Kopf der Datei (Zeilen 11–25):
- Er fasst die gesamte Philosophie dieses Controllers zusammen, wie weiter oben erläutert: Es werden nur drei Serveraktionen verwendet; die Berechnung erfolgt durch die [business]-Schicht im Browser; und die Liste der Simulationen ist ein einfaches, clientseitig gespeichertes Array – ein solcher Kommentar am Anfang der Datei ist eine gute Gewohnheit: Er verschafft dem Leser sofort einen Überblick, bevor er in die Details des Codes eintaucht.
Die Klassenfelder und der Konstruktor (Zeilen 26–44):
- Zeilen 28 und 29: DAO und views, bereits in der ersten Version dieses Clients vorhanden;
- Zeilen 30–32: neues Feld business vom Typ Business – das Fragezeichen (?) macht es zu einem optionalen Feld: Solange der Benutzer nicht authentifiziert ist, hat diese Eigenschaft noch keinen Wert (sie ist undefined);
- Zeilen 33 und 34: neues Feld „simulations“; das Array (anfangs leer, = []) ersetzt die früheren Serveraufrufe „list-simulations“ und „delete-simulation“;
- Zeilen 38 bis 40: Konfiguration von [axios], identisch mit der von [main3.ts] – insbesondere withCredentials = true, was unerlässlich ist, damit das Session-Cookie bei jeder Anfrage mitgesendet wird;
- Zeilen 42 und 43: Instanziierung der Schichten [dao] und [views] , unverändert gegenüber vorher.
Der Einstiegspunkt **start (Zeilen 47 bis 66):**
- Zeile 50: Das Allererste, was die Anwendung tut, ist der Aufruf von
init-session, der vor jeder anderen Aktion erforderlich ist (siehe die PHP-Datei [main.php], die jede Aktion blockiert, bis eine Session initialisiert wurde); - Zeilen 51 bis 56: Im Fehlerfall (Status ungleich 700) wird trotzdem die Authentifizierungs-View angezeigt, zusammen mit der vom Server zurückgegebenen Fehlermeldung;
- Zeilen 57 bis 63: Der
catch-Block behandelt den Fall, dass der Server überhaupt nicht erreichbar ist (Server ausgefallen, ungültige URL usw.) – ein Netzwerkfehler, der sich von einer einfachen Fehlerantwort des Servers unterscheidet; - Zeile 65: Wenn alles gut gelaufen ist, wird schließlich die Authentifizierungs-View ohne Fehlermeldung angezeigt – an dieser Stelle bleibt diese Methode identisch mit der vorherigen Version.
Die Authentifizierungs-View und die Initialisierung der [business]-Schicht (Zeilen 71–111):
- showAuthentication (Zeilen 71–75): unverändert; die Methode weist lediglich die [views]-Schicht an, diese View anzuzeigen, wobei die Methode
authenticateüber onSubmit als Callback dient; - authenticate (Zeilen 77–92): ruft dao.authenticateUser(user, password) auf; lautet der Status 200, wird nicht mehr wie früher direkt die Berechnungs-View angezeigt, sondern stattdessen this.initBusiness() (Zeile 84) aufgerufen, eine neue Methode; im Fehlerfall wird die Authentifizierungs-View unverändert mit der Fehlermeldung erneut angezeigt (Zeile 87);
- initBusiness (Zeilen 97–111), eine neue Methode: Sie ruft dao.getAdminData() auf – dies ist die einzige Stelle in der gesamten Datei, an der diese Aktion beim Server angefordert wird, und zwar ein für alle Mal; lautet der Status 1000, erzeugt sie das Business-Objekt mit den empfangenen Daten (Zeile 101, new Business(response.response)), setzt das Simulations-Array zurück (Zeile 103 – eine neue Authentifizierung entspricht einer neuen Arbeitssitzung) und zeigt schließlich die Berechnungs-View an (Zeile 104).
Die View für die Steuerberechnung (Zeilen 116–138):
- showCalculation (Zeilen 116–122): unverändert – sie kann mit oder ohne Ergebnis aufgerufen werden: ohne Ergebnis für ein leeres Formular (erster Besuch oder Rückkehr aus der Liste), mit Ergebnis unmittelbar nach einer erfolgreichen Berechnung;
- calculate (Zeilen 126–138): Dies ist die Methode, die sich am stärksten geändert hat. Sie ist nicht mehr asynchron und enthält keinen try/catch-Block für Netzwerkfehler mehr, da sie keine Serveraufrufe mehr ausführt; in Zeile 129 berechnet this.business!.calculateTax(married, children, salary) direkt das Ergebnis – das Ausrufezeichen (!) teilt TypeScript mit, dass wir sicher sind, dass
businessbereits initialisiert wurde (diese View ist nur nach initBusiness erreichbar); in den Zeilen 130 bis 134 werden die eingegebenen Parameter, die dieses Ergebnis nicht enthält, mit dem Spread-Operator ...result angehängt, um das vollständige simulation-Objekt zu bilden; in Zeile 136 speichert this.simulations.push(simulation) diese neue Simulation im Array des Browsers; in Zeile 137 wird die View schließlich mit diesem Ergebnis neu aufgebaut.
Die View mit der Liste der Simulationen (Zeilen 145 bis 158):
- showList (Zeilen 145–151): führt keine Serveraufrufe mehr aus – sie übergibt direkt this.simulations, das bereits im Speicher vorhandene Array, an die [views]-Schicht;
- deleteSimulation (Zeilen 153–158): In Zeile 156 entfernt this.simulations.splice(number, 1) die Simulation direkt aus dem Array des Browsers – das exakte Äquivalent der Anweisung simulations.splice(1, 1) in [main3.ts] –, danach wird in Zeile 157 die (aktualisierte) Liste erneut angezeigt.
Sitzungsende und Einstiegspunkt (Zeilen 163–189):
- endSession (Zeilen 163–171): Die Methode ruft nicht mehr dao.endSession() auf (diese Methode wurde aus [Dao3.ts] entfernt) – sie verwirft einfach die [business]-Schicht (Zeile 168, this.business = undefined) und die Simulationen (Zeile 169, this.simulations = []) und zeigt dann den Authentifizierungsbildschirm erneut an (Zeile 170); wie der Rest dieses Clients benötigt auch das Beenden der Sitzung daher keine Netzwerkanfragen mehr;
- formatError (Zeilen 177–182): unverändert – das Feld response eines Serverfehlers (PHP) ist manchmal ein String und manchmal ein Array von Strings (je nach Controller); diese Methode reduziert die Meldung immer auf einen einzigen String, der zur Anzeige bereit ist;
- Zeilen 186–188: Der Einstiegspunkt des Skripts außerhalb der Klasse bleibt unverändert – DOMContentLoaded stellt sicher, dass die HTML-Seite vollständig geladen ist, bevor der Controller erzeugt und start() aufgerufen wird; dies ist für diesen GUI-Client das Äquivalent zum Aufruf
main();am Ende von [main3.ts].
6.5.1.6. Kompilierung und Ausführung
Kompilierung und Ausführung erfolgen genau wie im vorherigen Abschnitt ([npm run build] oder [npm start]): Lediglich der Einstiegspunkt in [webpack.config.js] hat sich geändert. Hier die drei erhaltenen Bildschirme zum Vergleich mit den Screenshots aus dem eingangs bereitgestellten Dokument [web_application_views.odt]:

Authentifizierungsbildschirm: Der Benutzername ist der Einfachheit halber mit „admin“ vorbelegt; schlägt die Authentifizierung fehl, erscheint hier über dem Formular eine Fehlermeldung.

Bildschirm für die Steuerberechnung nach dem Absenden des ersten Formulars: Das grüne Feld zeigt das Ergebnis an, das im Browser von der [business]-Schicht berechnet wurde (tax, discount, reduction, surcharge, rate, hier in einen Prozentwert umgerechnet).

Bildschirm „List of your simulations“, erreichbar über den Link „List of simulations“: Jede Zeile entspricht einer im Array [this.simulations] des Browsers gespeicherten Simulation, zusammen mit ihrem Link „Delete“.
Die fünf Views sind folgende: Authentifizierung, Berechnung mit Ergebnis, Liste der Simulationen, Löschen einer Simulation (die die aktualisierte Liste erneut anzeigt) und Sitzungsende (das zum Authentifizierungsbildschirm zurückkehrt) – und das alles, ohne jemals Anfragen an den PHP-Server zu senden, abgesehen von den drei Aktionen init-session, authenticate-user und get-admindata.
6.6. Fazit
Dieses Kapitel hat gezeigt, wie dieselbe Grundlage an Geschäftslogik (die DAO- und Business-Schichten) sowohl über die Kommandozeile (node.js, Kapitel „Client HTTP 1“ und „Client HTTP 2“) als auch in einem Browser (Kapitel „Client HTTP 3“) ausgeführt werden kann – mithilfe eines geeigneten Kompilierwerkzeugs, hier webpack und ts-loader. Diese TypeScript-Grundlage ist der Ausgangspunkt für moderne Frontend-Frameworks (React, Vue, Angular ...), die auf denselben Bausteinen aufbauen: Module, Klassen, async/await und ein Build-Werkzeug, das sie für den Browser zusammenfügt.











