Skip to content

6. HTTP-Clients des Steuerberechnungs-Service

Image

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:

Image

Wir untersuchen zwei Versionen des Clients:

  • Version 1 des Clients hat folgenden Schichtenaufbau: [main, dao]:

Image

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

Image

6.2. HTTP-Client 1

Image

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

Image

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

'use strict';

// Importe
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao1 {

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

  // Konstruktor
  constructor(axios: AxiosInstance) {
    // Bibliothek axios, die für die HTTP-Anfragen verwendet wird
    this.axios = axios;
    // Session-Cookie
    this.sessionCookieName = "PHPSESSID";
    this.sessionCookie = '';
  }

  // Sitzung initialisieren
  async initSession(): Promise<any> {
    // Optionen der HTTP-Anfrage [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      // [TypeScript-Aktualisierung] URL in [options.url] enthalten (siehe getRemoteData)
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // Optionen der HTTP-Anfrage [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // Body des POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // URL-Parameter
      params: {
        action: 'authenticate-user'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  // Steuerberechnung
  async calculateTax(married: string, children: number, salary: number): Promise<any> {
    // Optionen der HTTP-Anfrage
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // Body des POST
      data: qs.stringify({
        married: married,
        children: children,
        salary: salary
      }),
      // URL-Parameter
      params: {
        action: 'calculate-tax'
      }
    };
    // Ausführung der HTTP-Anfrage
    const data = await this.getRemoteData(options);
    // Ergebnis
    return data;
  }

  // Liste der Simulationen
  async listSimulations(): Promise<any> {
    // Optionen der HTTP-Anfrage
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'list-simulations'
      },
    };
    // Ausführung der HTTP-Anfrage
    const data = await this.getRemoteData(options);
    // Ergebnis
    return data;
  }

  // eine Simulation löschen
  async deleteSimulation(index: number): Promise<any> {
    // Optionen der HTTP-Anfrage
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'delete-simulation',
        number: index
      },
    };
    // Ausführung der HTTP-Anfrage
    const data = await this.getRemoteData(options);
    // Ergebnis
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // für das Session-Cookie
    if (!options.headers) {
      options.headers = {} as any;
    }
    (options.headers as any).Cookie = this.sessionCookie;
    // Ausführung der HTTP-Anfrage
    let response: AxiosResponse;
    try {
      // asynchrone Anfrage
      response = await this.axios.request(options);
    } catch (error: any) {
      // der Parameter [error] ist eine Exception-Instanz - sie kann verschiedene Formen annehmen
      if (error.response) {
        // die Antwort des Servers steht in [error.response]
        response = error.response;
      } else {
        // wir werfen den Fehler erneut
        throw error;
      }
    }
    // response ist die gesamte HTTP-Antwort des Servers (HTTP-Header + die eigentliche Antwort)
    // wir rufen das Session-Cookie ab, falls vorhanden
    const setCookie = response.headers['set-cookie'];
    if (setCookie) {
      // setCookie ist ein Array
      // wir suchen das Session-Cookie in diesem Array
      let found = false;
      let i = 0;
      while (!found && i < setCookie.length) {
        // wir suchen das Session-Cookie
        const results = RegExp('^(' + this.sessionCookieName + '.+?);').exec(setCookie[i]);
        if (results) {
          // wir speichern das Session-Cookie
          // eslint-disable-next-line require-atomic-updates
          this.sessionCookie = results[1];
          // wir haben es gefunden
          found = true;
        } else {
          // nächstes Element
          i++;
        }
      }
    }
    // die Antwort des Servers steht in [response.data]
    return response.data;
  }
}

// Export der Klasse
export default Dao1;
  • 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:

// Import von axios
import axios from 'axios';
// Import der Klasse Dao
import Dao from './Dao1.js';


// asynchrone Funktion [main]
async function main(): Promise<void> {
  // Konfiguration von axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost:3000';
  // Instanziierung der Schicht [dao]
  const dao = new Dao(axios);
  // Verwendung der Schicht [dao]
  try {
    // Sitzung initialisieren
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    // Authentifizierung
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // Steuerberechnungen
    log("-----------calculate-tax x 3");
    response = await Promise.all([
      dao.calculateTax("yes", 2, 45000),
      dao.calculateTax("no", 2, 45000),
      dao.calculateTax("no", 1, 30000)
    ]);
    log(response);
    // Liste der Simulationen
    log("-----------list-of-simulations");
    response = await dao.listSimulations();
    log(response);
    // Löschen einer Simulation
    log("-----------deleting simulation no. 1");
    response = await dao.deleteSimulation(1);
    log(response);
  } catch (error: any) {
    // wir protokollieren den Fehler
    console.log("error=", error.message);
  }
}

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

// Ausführung
main();

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:

npx tsx main1.ts

Ausführungsergebnis:

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

6.3. HTTP-Client 2

Image

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

Image

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:

'use strict';

// Geschäftsklasse
class Business {

  // [any]: die genaue Struktur der vom Steuerserver gesendeten Daten (Sätze, Obergrenzen, ...)
  // ist hier nicht dokumentiert; wir bleiben bei diesem Typ daher bewusst flexibel
  taxAdminData: any;

  // Konstruktor
  constructor(taxAdmindata: any) {
    // this.taxAdminData: Daten der Steuerverwaltung
    this.taxAdminData = taxAdmindata;
  }

  // Steuerberechnung
  // --------------------------------------------------------------------------
  calculateTax(married: string, children: number, salary: number): any {
    // married: ja, nein
    // children: Anzahl der Kinder
    // salary: Jahresgehalt
    // this.taxAdminData: Daten der Steuerverwaltung
    //
    // Steuerberechnung mit Kindern
    const result1 = this.calculateTax2(married, children, salary);
    const tax1 = result1["tax"];
    // Steuerberechnung ohne die Kinder
    let result2, tax2, halfShareCeiling;
    if (children !== 0) {
      result2 = this.calculateTax2(married, 0, salary);
      tax2 = result2["tax"];
      // Anwendung der Obergrenze des Familienquotienten
      halfShareCeiling = this.taxAdminData.halfShareQfCeiling;
      if (children < 3) {
        // HALF_SHARE_QF_CEILING Euro für die ersten 2 Kinder
        tax2 = tax2 - children * halfShareCeiling;
      } else {
        // HALF_SHARE_QF_CEILING Euro für die ersten 2 Kinder, doppelt für die folgenden
        tax2 = tax2 - 2 * halfShareCeiling - (children - 2) * 2 * halfShareCeiling;
      }
    } else {
      // keine Neuberechnung der Steuer
      tax2 = tax1;
      result2 = result1;
    }
    // wir nehmen die höhere Steuer aus [tax1, tax2]
    let tax, rate, surcharge;
    if (tax1 > tax2) {
      tax = tax1;
      rate = result1["rate"];
      surcharge = result1["surcharge"];
    } else {
      surcharge = tax2 - tax1 + result2["surcharge"];
      tax = tax2;
      rate = result2["rate"];
    }
    // Berechnung eines möglichen Nachlasses
    const discount = this.getDiscount(married, tax);
    tax -= discount;
    // Berechnung einer möglichen Steuerermäßigung
    const reduction = this.getReduction(married, salary, children, tax);
    tax -= reduction;
    // Ergebnis
    return {
      "tax": Math.floor(tax), "surcharge": surcharge, "discount": discount, "reduction": reduction,
      "rate": rate
    };
  }

  // --------------------------------------------------------------------------
  calculateTax2(married: string, children: number, salary: number): any {
    // married: ja, nein
    // children: Anzahl der Kinder
    // salary: Jahresgehalt
    // this->taxAdminData: Daten der Steuerverwaltung
    // 
    // Anzahl der Anteile
    married = married.toLowerCase();
    let shares;
    if (married === "yes") {
      shares = children / 2 + 2;
    } else {
      shares = children / 2 + 1;
    }
    // 1 Anteil pro Kind ab dem 3.
    if (children >= 3) {
      // ein weiterer halber Anteil für jedes Kind ab dem 3.
      shares += 0.5 * (children - 2);
    }
    // zu versteuerndes Einkommen
    const taxableIncome = this.getTaxableIncome(salary);
    // Zuschlag
    let surcharge = Math.floor(taxableIncome - 0.9 * salary);
    // wegen Rundungsproblemen
    if (surcharge < 0) {
      surcharge = 0;
    }
    // Familienquotient
    const quotient = taxableIncome / shares;
    // Steuerberechnung
    const limits = this.taxAdminData.limits;
    const coeffR = this.taxAdminData.coeffR;
    const coeffN = this.taxAdminData.coeffN;
    // wird ans Ende des Arrays limits gesetzt, um die folgende Schleife zu stoppen
    limits[limits.length - 1] = quotient;
    // Suche nach dem Steuersatz
    let i = 0;
    while (quotient > limits[i]) {
      i++;
    }
    // da wir quotient ans Ende des Arrays limits gesetzt haben, kann die vorherige Schleife
    // nicht über das Array limits hinausgehen
    // jetzt können wir die Steuer berechnen
    const tax = Math.floor(taxableIncome * coeffR[i] - shares * coeffN[i]);
    // Ergebnis
    return { "tax": tax, "surcharge": surcharge, "rate": coeffR[i] };
  }

  // taxableIncome=annualSalary-allowance
  // der Freibetrag hat ein Minimum und ein Maximum
  getTaxableIncome(salary: number): number {
    // Freibetrag von 10 % des Gehalts
    let allowance = 0.1 * salary;
    // dieser Freibetrag darf taxAdminData.getTenPercentAllowanceMax() nicht überschreiten
    if (allowance > this.taxAdminData.tenPercentAllowanceMax) {
      allowance = this.taxAdminData.tenPercentAllowanceMax;
    }
    // der Freibetrag darf taxAdminData.getTenPercentAllowanceMin() nicht unterschreiten
    if (allowance < this.taxAdminData.tenPercentAllowanceMin) {
      allowance = this.taxAdminData.tenPercentAllowanceMin;
    }
    // zu versteuerndes Einkommen
    const taxableIncome = salary - allowance;
    // Ergebnis
    return Math.floor(taxableIncome);
  }

  // berechnet einen möglichen Nachlass
  getDiscount(married: string, taxes: number): number {
    // zunächst ein Nachlass von null
    let discount = 0;
    // maximaler Steuerbetrag, um den Nachlass zu erhalten
    let taxCeilingForDiscount = married === "yes" ?
      this.taxAdminData.coupleTaxCeilingForDiscount :
      this.taxAdminData.singleTaxCeilingForDiscount;
    let discountCeiling;
    if (taxes < taxCeilingForDiscount) {
      // maximaler Betrag des Nachlasses
      discountCeiling = married === "yes" ?
        this.taxAdminData.coupleDiscountCeiling :
        this.taxAdminData.singleDiscountCeiling;
      // theoretischer Nachlass
      discount = discountCeiling - 0.75 * taxes;
      // der Nachlass darf den Betrag der Steuer nicht überschreiten
      if (discount > taxes) {
        discount = taxes;
      }
      // kein Nachlass <0
      if (discount < 0) {
        discount = 0;
      }
    }
    // Ergebnis
    return Math.ceil(discount);
  }

  // berechnet eine mögliche Ermäßigung
  getReduction(married: string, salary: number, children: number, taxes: number): number {
    // die Einkommensgrenze, um Anspruch auf die Ermäßigung von 20 % zu haben
    let incomeCeilingForReduction = married === "yes" ?
      this.taxAdminData.coupleIncomeCeilingForReduction :
      this.taxAdminData.singleIncomeCeilingForReduction;
    incomeCeilingForReduction += children * this.taxAdminData.halfShareReductionValue;
    if (children > 2) {
      incomeCeilingForReduction += (children - 2) * this.taxAdminData.halfShareReductionValue;
    }
    // zu versteuerndes Einkommen
    const taxableIncome = this.getTaxableIncome(salary);
    // Ermäßigung
    let reduction = 0;
    if (taxableIncome < incomeCeilingForReduction) {
      // Ermäßigung von 20 %
      reduction = 0.2 * taxes;
    }
    // Ergebnis
    return Math.ceil(reduction);
  }
}

// Export der Klasse
export default Business;
  • 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]

Image

Die Klasse [Dao2] implementiert die [dao]-Schicht des obigen JavaScript-Clients wie folgt:

'use strict';

// Importe
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao2 {

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

  // Konstruktor
  constructor(axios: AxiosInstance) {
    this.axios = axios;
    // Session-Cookie
    this.sessionCookieName = "PHPSESSID";
    this.sessionCookie = '';
  }

  // Sitzung initialisieren
  async initSession(): Promise<any> {
    // Optionen der HTTP-Anfrage [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // Optionen der HTTP-Anfrage [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // Body des POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // URL-Parameter
      params: {
        action: 'authenticate-user'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  async getAdminData(): Promise<any> {
    // Optionen der HTTP-Anfrage  [get /main.php?action=get-admindata]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'get-admindata'
      }
    };
    // Ausführung der HTTP-Anfrage
    const data = await this.getRemoteData(options);
    // Ergebnis
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // für das Session-Cookie
    if (!options.headers) {
      options.headers = {} as any;
    }
    (options.headers as any).Cookie = this.sessionCookie;
    // Ausführung der HTTP-Anfrage
    let response: AxiosResponse;
    try {
      // asynchrone Anfrage
      response = await this.axios.request(options);
    } catch (error: any) {
      // der Parameter [error] ist eine Exception-Instanz - sie kann verschiedene Formen annehmen
      if (error.response) {
        // die Antwort des Servers steht in [error.response]
        response = error.response;
      } else {
        // wir werfen den Fehler erneut
        throw error;
      }
    }
    // response ist die gesamte HTTP-Antwort des Servers (HTTP-Header + die eigentliche Antwort)
    // wir rufen das Session-Cookie ab, falls vorhanden
    const setCookie = response.headers['set-cookie'];
    if (setCookie) {
      // setCookie ist ein Array
      // wir suchen das Session-Cookie in diesem Array
      let found = false;
      let i = 0;
      while (!found && i < setCookie.length) {
        // wir suchen das Session-Cookie
        const results = RegExp('^(' + this.sessionCookieName + '.+?);').exec(setCookie[i]);
        if (results) {
          // wir speichern das Session-Cookie
          // eslint-disable-next-line require-atomic-updates
          this.sessionCookie = results[1];
          // wir haben es gefunden
          found = true;
        } else {
          // nächstes Element
          i++;
        }
      }
    }
    // die Antwort des Servers steht in [response.data]
    return response.data;
  }
}

// Export der Klasse
export default Dao2;

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:

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

Der Inhalt der beiden Datenbanktabellen liegt in Form von JSON vor.

6.3.3. Das Skript [main2]

Image

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:

// Importe
import axios from 'axios';

// Importe
import Dao from './Dao2.js';
import Business from './Business.js';

// asynchrone Funktion [main]
async function main(): Promise<void> {
  // Konfiguration von axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost';
  // Instanziierung der Schicht [dao]
  const dao = new Dao(axios);
  // HTTP-Anfragen
  let taxAdminData: any;
  try {
    // Sitzung initialisieren
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    // Authentifizierung
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // Steuerdaten
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    taxAdminData = response.response;
  } catch (error: any) {
    // wir protokollieren den Fehler
    console.log("error=", error.message);
    // Ende
    return;
  }

  // Instanziierung der Schicht [business]
  const business = new Business(taxAdminData);

  // Steuerberechnungen
  log("-----------calculate-tax x 3");
  const simulations: any[] = [];
  simulations.push(business.calculateTax("yes", 2, 45000));
  simulations.push(business.calculateTax("no", 2, 45000));
  simulations.push(business.calculateTax("no", 1, 30000));
  // Liste der Simulationen
  log("-----------list-of-simulations");
  log(simulations);
  // Löschen einer Simulation
  log("-----------deleting simulation no. 1");
  simulations.splice(1, 1);
  log(simulations);
}

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

// Ausführung
main();
  • 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.
npx tsx main2.ts

Ausführungsergebnis:

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

6.4. HTTP-Client 3

In diesem Abschnitt führen wir [HTTP client 2] als Anwendung in einem Browser aus, gemäß der folgenden Architektur:

Image

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

/* eslint-disable */

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

/*
 * SplitChunksPlugin ist standardmäßig aktiviert und ersetzt das
 * veraltete CommonsChunkPlugin. Es erkennt automatisch Module, die
 * per Heuristik anhand der Anzahl der Modul-Duplikate und der
 * Modulkategorie (z. B. node_modules) in Chunks aufgeteilt werden sollten. Und teilt die Chunks auf…
 *
 * Es ist unbedenklich, "splitChunks" aus der generierten Konfiguration zu entfernen,
 * es wurde als didaktisches Beispiel hinzugefügt.
 *
 * https://webpack.js.org/plugins/split-chunks-plugin/
 *
 */

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

/*
 * Wir haben das HtmlWebpackPlugin für Sie aktiviert! Es erzeugt beim
 * Kompilieren von webpack eine HTML-Seite für Sie, wodurch Sie schneller
 * mit Entwicklung und Prototyping beginnen können.
 *
 * https://github.com/jantimon/html-webpack-plugin
 *
 */

// [TypeScript-Update] Die Quellen liegen jetzt in .ts vor: webpack muss sie auflösen
// (resolve.extensions) und mit [ts-loader] kompilieren statt mit
// [babel-loader] (der die TypeScript-Syntax nicht versteht: Typen, Interfaces, ...)
module.exports = {
  mode: "development",
  //entry: "./src/main3.ts",
  entry: "./src/index.ts",
  output: {
    filename: "[name].[chunkhash].js",
    path: path.resolve(__dirname, "dist")
  },

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

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

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

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

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

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

console.log("Hello, world");

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

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

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

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:

npm run build

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:

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

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:

npm run start

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

Ändern wir nun diesen Inhalt in die folgende Zeile in [index.ts]:

console.log("Hello World");

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:

Image

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

// Importe
import axios from 'axios';
import "core-js/stable";
import "regenerator-runtime/runtime";

// Importe
import Dao from './Dao3';
import Business from './Business';

// asynchrone Funktion [main]
async function main(): Promise<void> {
  // Konfiguration von axios
  axios.defaults.timeout = 2000;
  axios.defaults.baseURL = 'http://localhost:3000/';
  axios.defaults.withCredentials = true;
  // Instanziierung der Schicht [dao]
  const dao = new Dao(axios);
  // HTTP-Anfragen
  let taxAdminData: any;
  try {
    // Sitzung initialisieren
    log("-----------init-session");
    let response = await dao.initSession();
    log(response);
    if (response.status != 700) {
      throw new Error(JSON.stringify(response.response));
    }
    // authentication
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    if (response.status != 200) {
      throw new Error(JSON.stringify(response.response));
    }
    // Steuerdaten
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    if (response.status != 1000) {
      throw new Error(JSON.stringify(response.response));
    }
    taxAdminData = response.response;
  } catch (error: any) {
    // wir protokollieren den Fehler
    console.log("error=", error.message);
    // end
    return;
  }

  // Instanziierung der Schicht [business]
  const business = new Business(taxAdminData);

  // Steuerberechnungen
  log("-----------calculate-tax x 3");
  const simulations: any[] = [];
  simulations.push(business.calculateTax("yes", 2, 45000));
  simulations.push(business.calculateTax("no", 2, 45000));
  simulations.push(business.calculateTax("no", 1, 30000));
  // Liste der Simulationen
  log("-----------list-of-simulations");
  log(simulations);
  // Löschen einer Simulation
  log("-----------deleting simulation no. 1");
  simulations.splice(1, 1);
  log(simulations);
}

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

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

'use strict';

// Importe
import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
import qs from 'qs'

class Dao3 {

  private axios: AxiosInstance;

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

  // Sitzung initialisieren
  async initSession(): Promise<any> {
    // Optionen der HTTP-Anfrage [get /main.php?action=init-session&type=json]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'init-session',
        type: 'json'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  async authenticateUser(user: string, password: string): Promise<any> {
    // Optionen der HTTP-Anfrage [post /main.php?action=authenticate-user]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "POST",
      headers: {
        'Content-type': 'application/x-www-form-urlencoded',
      },
      // Body des POST
      data: qs.stringify({
        user: user,
        password: password
      }),
      // URL-Parameter
      params: {
        action: 'authenticate-user'
      }
    };
    // Ausführung der HTTP-Anfrage
    return await this.getRemoteData(options);
  }

  async getAdminData(): Promise<any> {
    // Optionen der HTTP-Anfrage  [get /main.php?action=get-admindata]
    const options: AxiosRequestConfig = {
      url: 'main.php',
      method: "GET",
      // URL-Parameter
      params: {
        action: 'get-admindata'
      }
    };
    // Ausführung der HTTP-Anfrage
    const data = await this.getRemoteData(options);
    // result
    return data;
  }

  async getRemoteData(options: AxiosRequestConfig): Promise<any> {
    // Ausführung der HTTP-Anfrage
    let response: AxiosResponse;
    try {
      // asynchrone Anfrage
      response = await this.axios.request(options);
    } catch (error: any) {
      // der Parameter [error] ist eine Exception-Instanz - sie kann verschiedene Formen annehmen
      if (error.response) {
        // die Antwort des Servers steht in [error.response]
        response = error.response;
      } else {
        // wir werfen den Fehler erneut
        throw error;
      }
    }
    // response is the whole HTTP response of the server (HTTP headers + the response itself)
    // the server's response is in [response.data]
    return response.data;
  }
}

// Export der Klasse
export default Dao3;

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

    * {
      box-sizing: border-box;
    }

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

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

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

    .banner .logo {
      flex: none;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    button:hover {
      background: #1976d2;
    }

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

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

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

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

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

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

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

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

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

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: flex nebeneinander 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:

module.exports = {
  mode: "development",
  // HTML-Client (Views für Authentifizierung / Berechnung / Liste der Simulationen)
  entry: "./src/AppHtml.ts",
  // ursprünglicher Einstiegspunkt des Projekts (Konsolentest der [dao]/[business]-Schichten),
  // zu Referenzzwecken beibehalten - Sie können dorthin zurückkehren, indem Sie die obige Zeile auskommentieren
  //entry: "./src/main3.ts",
  //entry: "./src/index.ts",
  output: {
    filename: "[name].[chunkhash].js",
    path: path.resolve(__dirname, "dist")
  },

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

  plugins: [
    new webpack.ProgressPlugin(),
    // Template speziell für den HTML-Client (Banner, Stile, <div id="app">)
    new HtmlWebpackPlugin({
      template: path.resolve(__dirname, "src/index.html")
    })
  ],
  • 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 private vor dem Parameter ist eine Kurzschreibweise, die automatisch ein Attribut root erzeugt, ohne dass this.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 error nicht 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 business bereits 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]:

Image

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

Image

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

Image

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.