Skip to content

6. HTTP-Clients für den Steuerberechnungsdienst

Image

6.1. Einführung

Dieses Kapitel gibt ohne strukturelle Änderungen die drei aufeinander folgenden Client-Schichten wieder, die im TypeScript-Kurs aufgebaut wurden und von denen jede die vorherige verfeinert: einen ersten CLI-Client, bei dem alle Berechnungen serverseitig bleiben; einen zweiten CLI-Client, bei dem die Berechnung auf die Clientseite wandert (Schicht [business]); einen dritten, für den BROWSER kompilierten Client; und schließlich einen vollständigen HTML-Client mit eigenen Views. Alle vier stützen sich auf denselben NestJS-Server, der im vorigen Kapitel installiert wurde.

6.2. HTTP-Client 1

Image

6.2.1. Die Schicht [dao]

6.2.2. Skript [dao1]

// dao1.dart
// Portiert Dao1.ts: Die [dao]-Schicht (Data Access Object) kapselt alle
// Details der HTTP-Kommunikation mit dem Steuerberechnungsserver (URL,
// Methode, Sitzungs-Cookie) hinter einfachen fachlichen Methoden
// (initSession, authenticateUser, calculateTax...).
import 'package:dio/dio.dart';

class Dao1 {
  final Dio _dio;
  final String _sessionCookieName;
  String _sessionCookie = '';

  // Konstruktor - erhält die zu verwendende Dio-Instanz, so wie das TypeScript-
  // Skript die axios-Instanz als Parameter erhielt
  Dao1(this._dio) : _sessionCookieName = "connect.sid";

  // Sitzung initialisieren
  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      data: {'user': user, 'password': password},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  // Steuerberechnung
  Future<dynamic> calculateTax(String married, int children, int salary) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'calculate-tax'},
      data: {'married': married, 'children': children, 'salary': salary},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  // Liste der Simulationen
  Future<dynamic> listSimulations() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'list-simulations'},
    );
  }

  // eine Simulation löschen
  Future<dynamic> deleteSimulation(int index) {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'delete-simulation', 'number': index},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Object? data,
    String? contentType,
  }) async {
    // für das Sitzungs-Cookie
    final options = Options(
      method: method,
      contentType: contentType,
      headers: {'Cookie': _sessionCookie},
      validateStatus: (_) => true,
    );
    // Ausführung der HTTP-Anfrage
    final response = await _dio.request(
      path,
      queryParameters: queryParameters,
      data: data,
      options: options,
    );
    // wir lesen das Sitzungs-Cookie aus, falls vorhanden
    final setCookie = response.headers['set-cookie'];
    if (setCookie != null) {
      for (final header in setCookie) {
        final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
        if (result != null) {
          _sessionCookie = result.group(1)!;
          break;
        }
      }
    }
    // die Antwort des Servers steht in [response.data]
    return response.data;
  }
}

Kommentieren wir diesen Code:

  • Zeile 48: Die Schicht [dao] (Data Access Object) kapselt alle Details der HTTP-Kommunikation (URL, Methode, Sitzungs-Cookie) hinter einfachen fachlichen Methoden - [initSession], [authenticateUser], [calculateTax], [listSimulations], [deleteSimulation] (Zeile 57).
  • Zeile 15: [Dao1(this._dio)] erhält die zu verwendende [Dio]-Instanz als Konstruktorparameter, genau wie das TypeScript-Skript die [axios]-Instanz erhielt.
  • Zeile 65: [_getRemoteData] (privat, Präfix [_]) zentralisiert die manuelle Verwaltung des Sitzungs-Cookies ([response.headers['set-cookie']], [RegExp] (Zeile 90)), die bereits in dart_dio_03.dart vorkam: Jede öffentliche Methode des DAO stützt sich auf dieselbe private Methode.

6.2.3. Das Programm [main1]

6.2.4. Skript [main1]

// main1.dart
// Portiert main1.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao1.dart';

Future<void> main() async {
  // Dio-Konfiguration - globale baseUrl/globaler timeout, wie axios.defaults in
  // TypeScript
  final dio = Dio(BaseOptions(
    baseUrl: 'http://localhost:3000/',
    connectTimeout: const Duration(seconds: 2),
    receiveTimeout: const Duration(seconds: 2),
  ));
  // Instanziierung der [dao]-Schicht
  final dao = Dao1(dio);
  // Verwendung der [dao]-Schicht
  try {
    // Sitzung initialisieren
    log("-----------init-session");
    dynamic response = await dao.initSession();
    log(response);
    // Authentifizierung
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    // Steuerberechnungen - Future.wait ist das Dart-Äquivalent zu Promise.all
    // (bereits gesehen in async_05.dart)
    log("-----------calculate-tax x 3");
    response = await Future.wait([
      dao.calculateTax("yes", 2, 45000),
      dao.calculateTax("no", 2, 45000),
      dao.calculateTax("no", 1, 30000),
    ]);
    log(response);
    // 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) {
    // wir protokollieren den Fehler
    print("error=$error");
  }
}

// JSON-Protokoll
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Kommentieren wir diesen Code:

  • Zeile 16: [final dao = Dao1(dio);]: Die Schicht [dao] wird nur einmal instanziiert und dann für die gesamte Aufrufsequenz wiederverwendet (init-session, Authentifizierung, Berechnungen, Liste, Löschen).
  • Zeilen 30–31: [Future.wait([dao.calculateTax(...), ...])]: Die drei Steuerberechnungen werden PARALLEL gestartet, das Dart-Äquivalent zu [Promise.all], dem wir bereits in async_05.dart begegnet sind.
  • Zeilen 52–53: [JsonEncoder.withIndent(' ').convert(object)]: Die Hilfsfunktion [log] bildet die eingerückte Ausgabe von [JSON.stringify(x, null, 2)] nach.

Das Ergebnis der Ausführung lautet:

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

6.3. HTTP-Client 2

Image

Dieser zweite Client verlagert die Steuer-BERECHNUNG vom Server auf den Client: Der Server liefert jetzt nur noch einmal über [get-admindata] die rohen Steuerdaten (Sätze, Schwellenwerte usw.), und die Schicht [business] führt nun die Berechnungen durch.

6.3.1. Die Klasse [Business]

6.3.2. Skript [business]

// business.dart
// Portiert Business.ts: Die Steuerberechnung erfolgt vollständig auf Client-Seite
// (in TypeScript im Browser, hier im Dart-Programm), ausgehend von
// den rohen Steuerdaten, die nur einmal über
// [Dao2.getAdminData] vom Server geholt werden (siehe dao2.dart).
class Business {
  // [dynamic]: Die genaue Struktur der vom Steuer-
  // Server gesendeten Daten (Sätze, Obergrenzen...) ist hier nicht dokumentiert; wie in
  // TypeScript bleiben wir bei diesem Typ bewusst flexibel
  final Map<String, dynamic> taxAdminData;

  Business(this.taxAdminData);

  // Steuerberechnung
  // --------------------------------------------------------------------------
  // married: ja, nein
  // children: Anzahl der Kinder
  // salary: Jahresgehalt
  Map<String, dynamic> calculateTax(String married, int children, num salary) {
    // Steuerberechnung mit Kindern
    final result1 = _calculateTax2(married, children, salary);
    final tax1 = result1['tax'] as num;
    // Steuerberechnung ohne die Kinder
    Map<String, dynamic> result2;
    num tax2;
    num halfShareCeiling;
    if (children != 0) {
      result2 = _calculateTax2(married, 0, salary);
      tax2 = result2['tax'] as num;
      // Anwendung der Obergrenze des Familienquotienten
      halfShareCeiling = taxAdminData['halfShareQfCeiling'] as num;
      if (children < 3) {
        // halfShareCeiling für die ersten 2 Kinder
        tax2 = tax2 - children * halfShareCeiling;
      } else {
        // halfShareCeiling 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]
    num tax;
    num rate;
    num surcharge;
    if (tax1 > tax2) {
      tax = tax1;
      rate = result1['rate'] as num;
      surcharge = result1['surcharge'] as num;
    } else {
      surcharge = tax2 - tax1 + (result2['surcharge'] as num);
      tax = tax2;
      rate = result2['rate'] as num;
    }
    // Berechnung eines möglichen Nachlasses
    final discount = _getDiscount(married, tax);
    tax -= discount;
    // Berechnung einer möglichen Steuerermäßigung
    final reduction = _getReduction(married, salary, children, tax);
    tax -= reduction;
    // Ergebnis
    return {
      'tax': tax.floor(),
      'surcharge': surcharge,
      'discount': discount,
      'reduction': reduction,
      'rate': rate,
    };
  }

  // --------------------------------------------------------------------------
  Map<String, dynamic> _calculateTax2(String married, int children, num salary) {
    // Anzahl der Anteile
    married = married.toLowerCase();
    num shares;
    if (married == "yes") {
      shares = children / 2 + 2;
    } else {
      shares = children / 2 + 1;
    }
    // 1 Anteil pro Kind ab dem 3.
    if (children >= 3) {
      // ein zusätzlicher halber Anteil für jedes Kind ab dem 3.
      shares += 0.5 * (children - 2);
    }
    // zu versteuerndes Einkommen
    final taxableIncome = _getTaxableIncome(salary);
    // Zuschlag
    num surcharge = (taxableIncome - 0.9 * salary).floor();
    // wegen Rundungsproblemen
    if (surcharge < 0) {
      surcharge = 0;
    }
    // Familienquotient
    final quotient = taxableIncome / shares;
    // Steuerberechnung
    final List<num> limits = List<num>.from(taxAdminData['limits'] as List);
    final List<num> coeffR = List<num>.from(taxAdminData['coeffR'] as List);
    final List<num> coeffN = List<num>.from(taxAdminData['coeffN'] as List);
    // wird ans Ende der Liste [limits] gesetzt, um die folgende Schleife zu stoppen
    limits[limits.length - 1] = quotient;
    // Suche nach dem Steuersatz
    var i = 0;
    while (quotient > limits[i]) {
      i++;
    }
    // da wir quotient ans Ende von limits gesetzt haben, kann die vorherige
    // Schleife nicht über die Liste limits hinausgehen
    // jetzt können wir die Steuer berechnen
    final tax = (taxableIncome * coeffR[i] - shares * coeffN[i]).floor();
    // Ergebnis
    return {'tax': tax, 'surcharge': surcharge, 'rate': coeffR[i]};
  }

  // taxableIncome = annualSalary - allowance (der Freibetrag hat ein Minimum und ein Maximum)
  num _getTaxableIncome(num salary) {
    // Freibetrag von 10 % des Gehalts
    num allowance = 0.1 * salary;
    // dieser Freibetrag darf tenPercentAllowanceMax nicht überschreiten
    final allowanceMax = taxAdminData['tenPercentAllowanceMax'] as num;
    if (allowance > allowanceMax) {
      allowance = allowanceMax;
    }
    // der Freibetrag darf nicht unter tenPercentAllowanceMin liegen
    final allowanceMin = taxAdminData['tenPercentAllowanceMin'] as num;
    if (allowance < allowanceMin) {
      allowance = allowanceMin;
    }
    // zu versteuerndes Einkommen
    final taxableIncome = salary - allowance;
    return taxableIncome.floor();
  }

  // berechnet einen möglichen Nachlass
  num _getDiscount(String married, num taxes) {
    // zunächst ein Nachlass von null
    num discount = 0;
    // maximaler Steuerbetrag, um den Nachlass zu erhalten
    final taxCeilingForDiscount = married == "yes"
        ? taxAdminData['coupleTaxCeilingForDiscount'] as num
        : taxAdminData['singleTaxCeilingForDiscount'] as num;
    if (taxes < taxCeilingForDiscount) {
      // maximaler Betrag des Nachlasses
      final discountCeiling = married == "yes"
          ? taxAdminData['coupleDiscountCeiling'] as num
          : taxAdminData['singleDiscountCeiling'] as num;
      // 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 - ceil() ist das Dart-Äquivalent zu Math.ceil()
    return discount.ceil();
  }

  // berechnet eine mögliche Ermäßigung
  num _getReduction(String married, num salary, int children, num taxes) {
    // die Einkommensgrenze, bis zu der Anspruch auf die Ermäßigung von 20 % besteht
    num incomeCeilingForReduction = married == "yes"
        ? taxAdminData['coupleIncomeCeilingForReduction'] as num
        : taxAdminData['singleIncomeCeilingForReduction'] as num;
    final halfShareReductionValue = taxAdminData['halfShareReductionValue'] as num;
    incomeCeilingForReduction += children * halfShareReductionValue;
    if (children > 2) {
      incomeCeilingForReduction += (children - 2) * halfShareReductionValue;
    }
    // zu versteuerndes Einkommen
    final taxableIncome = _getTaxableIncome(salary);
    // Ermäßigung
    num reduction = 0;
    if (taxableIncome < incomeCeilingForReduction) {
      // Ermäßigung von 20 %
      reduction = 0.2 * taxes;
    }
    return reduction.ceil();
  }
}

Analysieren wir diesen Code:

  • Zeile 12: [Business(this.taxAdminData)]: Der Konstruktor erhält die vom DAO nur einmal abgerufenen rohen Steuerdaten — danach sind keine weiteren Netzwerkaufrufe mehr nötig, um eine Steuer zu berechnen.
  • Zeile 19: [Map<String, dynamic> calculateTax(String married, int children, num salary)]: eine getreue, zeilenweise Portierung des TypeScript-Algorithmus — dieselben Schritte ([_calculateTax2], [_getTaxableIncome], [_getDiscount], [_getReduction]), dieselbe Logik zur Begrenzung des Familienquotienten.
  • [.floor()]/[.ceil()] (Methoden von [num]) ersetzen [Math.floor(...)]/[Math.ceil(...)]: In Dart sind dies Instanzmethoden der Zahl selbst und keine statischen Methoden einer Hilfsklasse.
  • Die SCHLÜSSEL der zurückgegebenen [Map] ([tax], [surcharge], [discount], [reduction]...) haben dieselben schlichten ASCII-Namen wie die Dart-BEZEICHNER (Variablen- und Parameternamen) — ein String darf in Dart Akzente enthalten, ein Bezeichner jedoch nicht (siehe simulation.dart weiter unten in diesem Kapitel).

6.3.3. Die Klasse [Dao2]

6.3.4. Skript [dao2]

// dao2.dart
// Portiert Dao2.ts: identisch mit dao1.dart bei initSession und
// authenticateUser, stellt aber [getAdminData] statt
// [calculateTax]/[listSimulations]/[deleteSimulation] bereit - die Berechnung und
// die Liste der Simulationen werden nun auf der CLIENT-Seite von der
// [business]-Schicht erledigt (siehe business.dart), der Server dient nur noch dazu, die
// rohen Steuerdaten (Sätze, Obergrenzen...) zu liefern.
import 'package:dio/dio.dart';

class Dao2 {
  final Dio _dio;
  final String _sessionCookieName;
  String _sessionCookie = '';

  Dao2(this._dio) : _sessionCookieName = "connect.sid";

  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      data: {'user': user, 'password': password},
      contentType: Headers.formUrlEncodedContentType,
    );
  }

  Future<dynamic> getAdminData() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'get-admindata'},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Object? data,
    String? contentType,
  }) async {
    final options = Options(
      method: method,
      contentType: contentType,
      headers: {'Cookie': _sessionCookie},
      validateStatus: (_) => true,
    );
    final response = await _dio.request(
      path,
      queryParameters: queryParameters,
      data: data,
      options: options,
    );
    final setCookie = response.headers['set-cookie'];
    if (setCookie != null) {
      for (final header in setCookie) {
        final result = RegExp('^($_sessionCookieName.+?);').firstMatch(header);
        if (result != null) {
          _sessionCookie = result.group(1)!;
          break;
        }
      }
    }
    return response.data;
  }
}

Kommentieren wir diesen Code:

  • Zeile 4: Identisch mit [Dao1] für [initSession] und [authenticateUser], stellt aber [getAdminData] anstelle von [calculateTax]/[listSimulations] (Zeile 4)/[deleteSimulation] (Zeile 4) bereit: Diese drei Operationen werden nun auf der CLIENT-Seite von der soeben eingeführten Schicht [business] übernommen.

6.3.5. Das Programm [main2]

6.3.6. Skript [main2]

// main2.dart
// Portiert main2.ts.
import 'dart:convert';
import 'package:dio/dio.dart';
import 'dao2.dart';
import 'business.dart';

Future<void> main() async {
  // Dio-Konfiguration
  final dio = Dio(BaseOptions(
    baseUrl: 'http://localhost:3000/',
    connectTimeout: const Duration(seconds: 2),
    receiveTimeout: const Duration(seconds: 2),
  ));
  // Instanziierung der [dao]-Schicht
  final dao = Dao2(dio);
  // HTTP-Anfragen
  Map<String, dynamic> taxAdminData;
  try {
    // Sitzung initialisieren
    log("-----------init-session");
    dynamic 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'] as Map<String, dynamic>;
  } catch (error) {
    // wir protokollieren den Fehler
    print("error=$error");
    // Ende
    return;
  }

  // Instanziierung der [business]-Schicht
  final business = Business(taxAdminData);

  // Steuerberechnungen
  log("-----------calculate-tax x 3");
  final List<Map<String, dynamic>> simulations = [];
  simulations.add(business.calculateTax("yes", 2, 45000));
  simulations.add(business.calculateTax("no", 2, 45000));
  simulations.add(business.calculateTax("no", 1, 30000));
  // Liste der Simulationen
  log("-----------list-of-simulations");
  log(simulations);
  // Löschen einer Simulation
  log("-----------deleting simulation no. 1");
  simulations.removeAt(1);
  log(simulations);
}

// JSON-Protokoll
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Kommentieren wir diesen Code:

  • Zeile 41: [final business = Business(taxAdminData);]: Die Schicht [business] wird nur EINMAL instanziiert, unmittelbar nach dem Abruf der Steuerdaten vom Server.
  • [simulations.add(business.calculateTax(...));]: Die Steuerberechnungen erfordern KEINEN Netzwerkaufruf mehr — anders als in main1.dart, wo jede Berechnung eine eigene HTTP-Anfrage war.

Das Ergebnis der Ausführung lautet:

"-----------init-session"
{
"action": "init-session",
"status": 700,
"response": "session started with type [json]"
}
"-----------authenticate-user"
{
"action": "authenticate-user",
"status": 200,
"response": "Authentication successful [admin, admin]"
}
"-----------get-admindata"
{
"action": "get-admindata",
"status": 1000,
"response": {
"limits": [
9964,
27519,
73779,
156244,
0
],
"coeffR": [
0,
0.14,
0.3,
0.41,
0.45
],
"coeffN": [
0,
1394.96,
5798,
13913.69,
20163.45
],
"halfShareQfCeiling": 1551,
"singleIncomeCeilingForReduction": 21037,
"coupleIncomeCeilingForReduction": 42074,
"halfShareReductionValue": 3797,
"singleDiscountCeiling": 1196,
"coupleDiscountCeiling": 1970,
"coupleTaxCeilingForDiscount": 2627,
"singleTaxCeilingForDiscount": 1595,
"tenPercentAllowanceMax": 12502,
"tenPercentAllowanceMin": 437
}
}
"-----------calculate-tax x 3"
"-----------list-of-simulations"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 3250,
"surcharge": 370,
"discount": 0,
"reduction": 0,
"rate": 0.3
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]
"-----------deleting simulation no. 1"
[
{
"tax": 502,
"surcharge": 0,
"discount": 857,
"reduction": 126,
"rate": 0.14
},
{
"tax": 1687,
"surcharge": 0,
"discount": 0,
"reduction": 0,
"rate": 0.14
}
]

6.4. HTTP-Client 3

Image

6.4.1. Entwicklung der Werkzeuge seit 2019

Dieser dritte Client verwendet dasselbe Paar [dao]/[business] wie HTTP-Client 2, wird aber FÜR DEN BROWSER KOMPILIERT, statt von der Kommandozeile ausgeführt zu werden. Wie bei TypeScript erfordert dieser Build webpack und babel sowie Polyfills ([core-js/stable], [regenerator-runtime/runtime]), damit moderner Code auch in älteren Browsern funktioniert. Auf der Dart-Seite bringt das SDK seinen eigenen Web-Compiler mit ([dart compile js]): Es sind keine Polyfills nötig; [Future]/[async]/[await], Records, Patterns usw. werden unabhängig vom Ziel direkt in das entsprechende JavaScript kompiliert.

6.4.2. Kompilieren und Ausführen des Projekts

Aus dem Ordner [http client 3]:

Der Entwicklungsserver [webdev serve] wird nicht mit dem Dart-SDK mitgeliefert: Das Paket [webdev] muss zuvor einmalig global mit [dart pub global activate webdev] installiert werden.

Dieser Befehl installiert die ausführbare Datei [webdev] im globalen Pub-Cache, einem Ordner, der nicht automatisch im Windows-PATH enthalten ist. Um ihn dort ein für alle Mal (für den aktuellen Benutzer) hinzuzufügen, öffnen Sie ein PowerShell-Terminal und führen Sie Folgendes aus:

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";$env:LOCALAPPDATA\Pub\Cache\bin", "User")

Anschließend müssen Sie das Terminal (oder VSCode) schließen und neu öffnen, damit der neue PATH wirksam wird. Dann, weiterhin im Ordner [http client 3]:

dart pub get
webdev serve

Während der Entwicklung startet [webdev serve] einen Server, der bei jeder Änderung automatisch neu kompiliert (Hot Reload): Das Terminal zeigt die URL an, die im Browser geöffnet werden soll (Standard: http://localhost:8080). Für einen Produktions-Build steht weiterhin der Befehl [dart compile js web/main.dart -o web/main.dart.js] zur Verfügung: Die Seite [web/index.html] lädt dann [main.dart.js], um das Ergebnis zu testen — dasselbe Konzept wie der minimale Einstiegspunkt [src/index.ts] im TypeScript-Kurs.

6.4.3. Das Skript [main3]

6.4.4. Skript [main3]

// main3.dart
// Portiert main3.ts.
//
// [WARNUNG, grundlegender Unterschied zu TypeScript] main3.ts brauchte
// zwei Polyfills (core-js/stable, regenerator-runtime), damit
// async/await und neuere JavaScript-Funktionen in
// alten Browsern funktionieren, nachdem sie von babel/webpack transpiliert wurden. Der
// Dart-Compiler für das Web (`dart compile js`) braucht KEINEN
// Polyfill dieser Art: Future/async/await, Records, Patterns...
// werden direkt in äquivalentes JavaScript oder WebAssembly kompiliert,
// egal welches Ziel - ein direkter Vorteil davon, aus
// einer einheitlichen Sprache und Toolchain zu kompilieren, statt
// "modernes" JavaScript in "altes" JavaScript zu transpilieren.
import 'dart:convert';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';

Future<void> main() async {
  // browserspezifischer HTTP-Client mit withCredentials=true -
  // das Dart-Äquivalent zu "axios.defaults.withCredentials = true"
  final client = BrowserClient()..withCredentials = true;
  final dao = Dao3(client, 'http://localhost:3000');

  Map<String, dynamic> taxAdminData;
  try {
    log("-----------init-session");
    Map<String, dynamic> response = await dao.initSession();
    log(response);
    if (response['status'] != 700) {
      throw Exception(jsonEncode(response['response']));
    }
    log("-----------authenticate-user");
    response = await dao.authenticateUser("admin", "admin");
    log(response);
    if (response['status'] != 200) {
      throw Exception(jsonEncode(response['response']));
    }
    log("-----------get-admindata");
    response = await dao.getAdminData();
    log(response);
    if (response['status'] != 1000) {
      throw Exception(jsonEncode(response['response']));
    }
    taxAdminData = response['response'] as Map<String, dynamic>;
  } catch (error) {
    print("error=$error");
    return;
  } finally {
    client.close();
  }

  // Instanziierung der [business]-Schicht
  final business = Business(taxAdminData);

  log("-----------calculate-tax x 3");
  final List<Map<String, dynamic>> simulations = [];
  simulations.add(business.calculateTax("yes", 2, 45000));
  simulations.add(business.calculateTax("no", 2, 45000));
  simulations.add(business.calculateTax("no", 1, 30000));
  log("-----------list-of-simulations");
  log(simulations);
  log("-----------deleting simulation no. 1");
  simulations.removeAt(1);
  log(simulations);
}

// JSON-Protokoll
void log(Object? object) {
  const JsonEncoder encoder = JsonEncoder.withIndent('  ');
  print(encoder.convert(object));
}

Kommentieren wir diesen Code:

  • Zeile 22: [final client = BrowserClient()..withCredentials = true;]: [BrowserClient] ([package:http/browser_client.dart]) existiert nur, wenn der Code für das Web kompiliert wird; seine Option [withCredentials] ist das Dart-Äquivalent zu [axios.defaults.withCredentials = true] — der BROWSER verwaltet dann das Sitzungs-Cookie selbstständig.
  • Der Dart-Web-Compiler benötigt KEINERLEI Polyfill (anders als main3.ts): [Future]/[async]/[await] und neuere Sprachfeatures werden direkt kompiliert — ein unmittelbarer Vorteil, wenn man mit einer einheitlichen Sprache und Werkzeugkette beginnt, statt modernes JavaScript in älteres JavaScript zu transpilieren.

6.4.5. Die Klasse [Dao3]

6.4.6. Skript [dao3]

// dao3.dart
// Portiert tax client/http client 3/src/Dao3.ts.
//
// Unterschied zu dao2.dart: Diese Datei ist dafür gedacht, für den
// BROWSER kompiliert zu werden (mit `dart compile js`, siehe die README dieses Ordners), nicht
// auf der CLI mit `dart run` ausgeführt zu werden. In einem Browser wird das
// SITZUNGS-COOKIE vom Browser selbst automatisch verwaltet (wie bei jeder
// Webseite), sobald das Senden erlaubt ist - es ist also nicht mehr
// nötig, die in dao1.dart/dao2.dart von Hand erfolgende MANUELLE Cookie-Verwaltung
// durchzuführen (genau die bereits vorhandene Überlegung, die es Dao3.ts erlaubte,
// den gesamten Cookie-Code von Dao2.ts zu entfernen).
//
// [Zuordnung zu TypeScript] "axios.defaults.withCredentials = true"
// (in main3.dart gesetzt, nicht hier) entspricht auf Seiten des Dart-Pakets [http]
// der Option [withCredentials] des webspezifischen Clients
// [BrowserClient] (package:http/browser_client.dart) - einer Klasse, die
// NUR beim Kompilieren für das Web existiert, anders als
// http.Client, der überall funktioniert.
import 'dart:convert';
import 'package:http/http.dart' as http;

class Dao3 {
  final http.Client _client;
  final String _baseUrl;

  Dao3(this._client, this._baseUrl);

  Future<dynamic> initSession() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'init-session', 'type': 'json'},
    );
  }

  Future<dynamic> authenticateUser(String user, String password) {
    return _getRemoteData(
      'main.php',
      method: 'POST',
      queryParameters: {'action': 'authenticate-user'},
      body: {'user': user, 'password': password},
    );
  }

  Future<dynamic> getAdminData() {
    return _getRemoteData(
      'main.php',
      method: 'GET',
      queryParameters: {'action': 'get-admindata'},
    );
  }

  Future<dynamic> _getRemoteData(
    String path, {
    required String method,
    Map<String, dynamic>? queryParameters,
    Map<String, String>? body,
  }) async {
    final uri = Uri.parse('$_baseUrl/$path').replace(
      queryParameters: queryParameters?.map((k, v) => MapEntry(k, '$v')),
    );
    final http.Response response;
    if (method == 'POST') {
      response = await _client.post(uri, body: body);
    } else {
      response = await _client.get(uri);
    }
    // [Unterschied zum CLI-Client] kein manuelles Auslesen des Headers set-cookie
    // hier: In einem Browser legt response.headers ihn gar nicht offen
    // (vom Browser geschützter Header, unsichtbar für den
    // JavaScript-/Dart-Code, gerade weil er bereits vom Browser selbst verarbeitet wird)
    return jsonDecode(response.body);
  }
}

Kommentieren wir diesen Code:

  • KEINE manuelle Verwaltung des Sitzungs-Cookies mehr (anders als bei [Dao1]/[Dao2]): In einem Browser wird das Sitzungs-Cookie automatisch vom Browser selbst verwaltet, sofern das Senden von Cookies erlaubt ist ([withCredentials], in main3.dart gesetzt).
  • [response.headers] stellt den Header [set-cookie] in einem Browser nicht einmal mehr bereit: ein geschützter Header, für den clientseitigen JavaScript-/Dart-Code unsichtbar, gerade weil er bereits eigenständig verwaltet wird.

6.4.7. Kompilierung und Ausführung

Siehe den Abschnitt [Compiling and Running the Project] oben: Derselbe Befehl [dart compile js] kompiliert [web/main.dart], das an [main3.dart] delegiert.

Starten Sie den Entwicklungsserver, um die Webanwendung des Http3-Clients auszuführen:

1
2
3
4
5
PS C:\Data\st-2026\dev\dart-sept-2026-scripts\dart-fundamentals\tax-client\dart-fundamentals\tax client\http client 3> webdev serve
[INFO] Serving `web` on http://127.0.0.1:8080
[INFO] ------------------------------------------------------------------------------------
[INFO] Injected debugging metadata for entrypoint at http://127.0.0.1:8080/main.dart.bootstr
[INFO] Injected debugging metadata for entrypoint at http://localhost:8080/main.dart.bootstrap.js

Das Ergebnis der Ausführung lautet:

Image

  • In [1] öffnen Sie einen Browser und rufen die URL [http://localhost:8080] auf;
  • in [2] der von der aufgerufenen Seite angezeigte Text;
  • in [3] finden Sie das Ergebnis der Ausführung in der Browserkonsole (F12, dann die Option Console). Wir erhalten dasselbe Ergebnis wie zuvor, diesmal jedoch in einem Browser;

6.5. HTML-Client

Image

6.5.1. Lösungsarchitektur

Dieser vierte und letzte Client setzt auf HTTP-Client 3 eine echte HTML-Oberfläche auf: Die Schichten [dao] ([Dao3]) und [business] ([Business]) werden UNVERÄNDERT WIEDERVERWENDET, und es kommen zwei neue Schichten hinzu — VIEWS (Aufbau des DOM) und CONTROLLER (Orchestrierung). Das Projekt ist in zwei Ordner gegliedert, [web/] (Einstiegspunkt, HTML, CSS) und [lib/] (gemeinsamer Code), gemäß der Konvention eines Standard-Dart-Webprojekts — Details zu dieser Konvention finden Sie in der README.md in diesem Ordner.

6.5.2. Das HTML-Template: die Datei [web/index.html]

Exakt aus [src/index.html] kopiert (dieselben CSS-Klassen: [banner], [menu], [content], [section-title], [field-row], [result], [error], [simulations]...), mit einem kleinen Unterschied: Das geladene Skript ist [main.dart.js] (ein FESTER, vom Dart-Webwerkzeug vorgegebener Name), während [index.html] aus Views.ts ein Webpack-Bundle mit einem Namen mit HASH ([main.a44f6e1c12ab338daedc.js]) geladen hat.

6.5.3. Die geänderte Konfiguration [webpack.config.js]

Auf der Dart-Seite ist nichts Vergleichbares nötig: Es muss keine Konfigurationsdatei für einen Bundler geschrieben werden. [web/main.dart] übernimmt allein durch seine POSITION im Verzeichnisbaum (direkt unter [web/]) die Rolle, die die Zeile [entry: './src/main3.ts'] für [webpack.config.js] spielte — eine Namens- und Ortskonvention ersetzt eine ganze Konfigurationsdatei.

6.5.4. Die Schichten [dao] und [business]: zwei unverändert wiederverwendete Dateien

[lib/dao3.dart] und [lib/business.dart] sind EXAKTE Kopien der gleichnamigen Dateien aus HTTP-Client 3 - dieselbe Wiederverwendung ohne jede Änderung, wie sie Views.ts und AppHtml.ts für [Dao3.ts] und [Business.ts] vornahmen.

6.5.5. Die Schicht [views]: die Datei [Views.ts]

6.5.6. Skripte [simulation, views]

Die Views-Schicht stützt sich auf DREI Dateien: simulation.dart (die angezeigten Daten), views.dart (der Aufbau des DOM) und app_html.dart (der Controller, der im nächsten Abschnitt behandelt wird). Beginnen wir mit simulation.dart:

// simulation.dart
// Das Ergebnis einer Steuerberechnung, wie es von business.dart geliefert wird,
// ergänzt um die eingegebenen Parameter. Portiert das Interface [Simulation] aus Views.ts.
//
// [NEU, Dart 3] hier verwenden wir einen benannten RECORD (siehe
// dart-fundamentals/dart3/dart3_01_records.dart) statt einer Klasse: ein
// einfacher Typalias [typedef], ohne Konstruktor oder eigene Datei,
// für Daten, die nur ein schlichtes "Bündel" von Feldern sind, ohne
// zugehöriges Verhalten - genau im Geist des ursprünglichen TypeScript-
// Interface.
//
// [HINWEIS zu Feldnamen] Anders als in TypeScript/JavaScript, wo
// ein Bezeichner Buchstaben mit Akzenten enthalten darf (im ursprünglichen
// französischen Kurs durchgehend verwendet), beschränkt Dart
// Bezeichner auf ASCII-Buchstaben: Akzente sind nur in
// ZEICHENKETTEN möglich, nie im Namen einer
// Variablen, eines Felds, einer Klasse oder eines Records. Jedenfalls verwendet dieser
// Kurs überall schlichte englische ASCII-Namen (married, tax, discount...):
// Die Felder des Records unten heißen genauso wie die Map-Schlüssel von
// business.dart.
typedef Simulation = ({
  String married,
  int children,
  num salary,
  num tax,
  num surcharge,
  num discount,
  num reduction,
  num rate,
});

Analysieren wir diesen Code:

  • Zeilen 21–24: [typedef Simulation = ({String married, int children, num salary, ...});]: Während Views.ts ein INTERFACE [Simulation] deklarierte, verwendet diese Datei ein BENANNTES Record aus Dart 3 (siehe dart3_01_records.dart) — ein einfacher Typalias ohne Konstruktor und ohne eigene Datei, für rein beschreibende Daten.
  • Die Feldnamen sind schlichtes ASCII ([married], [tax], [discount]...): Dart-BEZEICHNER sind auf ASCII-Buchstaben beschränkt, anders als in TypeScript/JavaScript, wo Namen mit Akzenten wie [marié]/[impôt] (im ursprünglichen französischen Kurs verwendet) gültige Feldnamen sind.

[lib/views.dart], das auf DOM und [package:web] aufbaut:

// views.dart
// Portiert Views.ts: Aufbau der Views (DOM) der Anwendung - Authentifizierungs-View,
// View der Steuerberechnung, View der Liste der Simulationen. Dieses
// Modul führt keinen Netzwerkaufruf aus: Es baut das DOM auf und delegiert die
// Aktionen des Benutzers an Callback-Funktionen, die vom
// Controller bereitgestellt werden (siehe app_html.dart).
//
// [technische Entscheidung] hier verwenden wir [package:web] (pub.dev/packages/web),
// den modernen Ersatz für das alte dart:html: Es stellt eine DOM-API bereit, die dem
// von Views.ts verwendeten Standard-DOM sehr nahekommt (document.createElement,
// .textContent, .addEventListener...). Ein oberflächlicher Unterschied, den man
// kennen sollte: Ein Dart-Ereignishandler (eine einfache Funktion) muss
// mit [.toJS] (Erweiterung von
// dart:js_interop) in eine JavaScript-Funktion umgewandelt werden, bevor er an [addEventListener] übergeben wird - die "Brücke"
// zwischen der Dart-Welt und der JavaScript-Welt, hier explizit gemacht, während
// TypeScript keine Umwandlung braucht (dort ist alles bereits
// JavaScript).
import 'dart:js_interop';
import 'package:web/web.dart' as web;
import 'simulation.dart';

// eine generische Dekoration (nicht das Foto des ursprünglichen PHP-Servers)
const String _logoSvg = '''
<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
  <circle cx="30" cy="30" r="29" fill="#eef1ec" stroke="#ccc" />
  <g fill="none" stroke="#8a9a7a" stroke-width="2">
    <path d="M30 46 C30 32 22 28 17 19" />
    <path d="M30 46 C30 30 39 26 44 17" />
    <path d="M30 46 C30 37 30 30 30 21" />
  </g>
  <g fill="#b9c9a6">
    <circle cx="17" cy="19" r="4.5" />
    <circle cx="44" cy="17" r="4.5" />
    <circle cx="30" cy="19" r="4.5" />
  </g>
</svg>''';

// Callbacks der View [authentication] - [Unterschied zu TypeScript]
// ein TypeScript-Interface mit Callbacks lässt sich in Dart natürlich in ein
// RECORD von Funktionen übersetzen (siehe simulation.dart): leichter als eine
// Klasse, für eine einfache Gruppe von Funktionen
typedef AuthenticationCallbacks = ({void Function(String user, String password) onSubmit});

typedef CalculationCallbacks = ({
  void Function(String married, int children, int salary) onSubmit,
  void Function() onList,
  void Function() onEndSession,
});

typedef ListCallbacks = ({
  void Function(int number) onDelete,
  void Function() onCalculation,
  void Function() onEndSession,
});

class Views {
  final web.HTMLElement root;
  late web.HTMLDivElement _banner;
  late web.HTMLDivElement _menu;
  late web.HTMLDivElement _content;

  // baut die feste Struktur der Seite auf (Banner + Menü-/Inhaltsbereich)
  // innerhalb des Elements [root]
  Views(this.root) {
    // [WARNUNG] Anders als gewöhnliche DOM-Eigenschaften (textContent,
    // value...) erwartet der Setter [innerHTML] von package:web ein [JSAny], keinen
    // rohen Dart-[String] - eine Eigenheit seiner Generierung, die mit dem
    // WebIDL-Attribut [LegacyNullToEmptyString] des Standard-DOM zusammenhängt: Wir
    // müssen also immer mit [.toJS] umwandeln.
    root.innerHTML = ''.toJS;

    _banner = _div()..className = 'banner';
    final logo = _div()..className = 'logo';
    logo.innerHTML = _logoSvg.toJS;
    final title = web.document.createElement('h1') as web.HTMLHeadingElement;
    title.textContent = 'Calculate your tax';
    _banner
      ..appendChild(logo)
      ..appendChild(title);

    final body = _div()..className = 'page-body';
    _menu = _div()..className = 'menu';
    _content = _div()..className = 'content';
    body
      ..appendChild(_menu)
      ..appendChild(_content);

    root
      ..appendChild(_banner)
      ..appendChild(body);
  }

  // --------------------------------------------------------------------
  // Werkzeuge zum Aufbau des DOM
  // --------------------------------------------------------------------

  web.HTMLDivElement _div() => web.document.createElement('div') as web.HTMLDivElement;

  void _clearMenu() {
    _menu.innerHTML = ''.toJS;
    _menu.style.display = 'none';
    _content.classList.add('full-width');
  }

  web.HTMLAnchorElement _menuLink(String text, void Function() onClick) {
    final a = web.document.createElement('a') as web.HTMLAnchorElement;
    a.textContent = text;
    a.addEventListener('click', ((web.Event event) => onClick()).toJS);
    return a;
  }

  void _showMenu(List<web.HTMLAnchorElement> links) {
    _menu.innerHTML = ''.toJS;
    _menu.style.display = '';
    _content.classList.remove('full-width');
    for (final link in links) {
      _menu.appendChild(link);
    }
  }

  web.HTMLElement? _errorBanner(String? message) {
    if (message == null) return null;
    final div = _div()..className = 'error';
    div.textContent = message;
    return div;
  }

  // eine Formularzeile [Label + Text-/Passwort-/Zahlenfeld]
  (web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(
    String labelText,
    String type,
    String initialValue, {
    String? help,
  }) {
    final row = _div()..className = 'field-row';
    final label = web.document.createElement('label') as web.HTMLLabelElement;
    label.textContent = labelText;
    final field = _div()..className = 'field';
    final input = web.document.createElement('input') as web.HTMLInputElement;
    input.type = type;
    input.value = initialValue;
    if (type == 'number') {
      input.min = '0';
    }
    field.appendChild(input);
    if (help != null) {
      final div = _div()..className = 'help';
      div.textContent = help;
      field.appendChild(div);
    }
    row
      ..appendChild(label)
      ..appendChild(field);
    return (row, input);
  }

  // --------------------------------------------------------------------
  // View [authentication]
  // --------------------------------------------------------------------
  void authenticationView(String? error, AuthenticationCallbacks callbacks) {
    _clearMenu();
    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'Please authenticate';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    final userField = _fieldRow("Username", 'text', 'admin');
    final passwordField = _fieldRow('Password', 'password', '');
    _content
      ..appendChild(userField.$1)
      ..appendChild(passwordField.$1);

    final button = web.document.createElement('button') as web.HTMLButtonElement;
    button.textContent = 'Submit';
    button.addEventListener(
      'click',
      ((web.Event event) {
        callbacks.onSubmit(userField.$2.value.trim(), passwordField.$2.value);
      }).toJS,
    );
    _content.appendChild(button);
  }

  // --------------------------------------------------------------------
  // View [tax calculation]
  // --------------------------------------------------------------------
  void calculationView(Simulation? result, String? error, CalculationCallbacks callbacks) {
    _showMenu([
      _menuLink('List of simulations', callbacks.onList),
      _menuLink('End of session', callbacks.onEndSession),
    ]);

    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'Fill in the form below and then submit it';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    // Zeile der Radiobuttons für [married]
    final marriedRow = _div()..className = 'field-row';
    final marriedLabel = web.document.createElement('label') as web.HTMLLabelElement;
    marriedLabel.textContent = 'Are you married or in a civil partnership?';
    final marriedField = _div()..className = 'field radios';

    final radioYes = web.document.createElement('input') as web.HTMLInputElement;
    radioYes.type = 'radio';
    radioYes.name = 'married';
    radioYes.value = 'yes';
    radioYes.checked = true;
    final labelYes = web.document.createElement('label') as web.HTMLLabelElement;
    labelYes.appendChild(radioYes);
    labelYes.appendChild(web.document.createTextNode(' Yes'));

    final radioNo = web.document.createElement('input') as web.HTMLInputElement;
    radioNo.type = 'radio';
    radioNo.name = 'married';
    radioNo.value = 'no';
    final labelNo = web.document.createElement('label') as web.HTMLLabelElement;
    labelNo.appendChild(radioNo);
    labelNo.appendChild(web.document.createTextNode(' No'));

    marriedField
      ..appendChild(labelYes)
      ..appendChild(labelNo);
    marriedRow
      ..appendChild(marriedLabel)
      ..appendChild(marriedField);
    _content.appendChild(marriedRow);

    final childrenField = _fieldRow("Number of dependent children", 'number', '0');
    _content.appendChild(childrenField.$1);

    final salaryField = _fieldRow(
      'Annual salary',
      'number',
      '',
      help: "Round down to the nearest euro",
    );
    _content.appendChild(salaryField.$1);

    final button = web.document.createElement('button') as web.HTMLButtonElement;
    button.textContent = 'Submit';
    button.addEventListener(
      'click',
      ((web.Event event) {
        final married = radioYes.checked ? 'yes' : 'no';
        final children = int.tryParse(childrenField.$2.value) ?? 0;
        final salary = int.tryParse(salaryField.$2.value) ?? 0;
        callbacks.onSubmit(married, children, salary);
      }).toJS,
    );
    _content.appendChild(button);

    // Ergebnis der letzten Simulation (grünes Feld), falls vorhanden
    if (result != null) {
      final box = _div()..className = 'result';
      final ratePercent = (result.rate * 100).round();
      box.innerHTML = ("Tax amount: ${result.tax} euros<br>"
              "Discount: ${result.discount} euros<br>"
              "Reduction: ${result.reduction} euros<br>"
              "Surcharge: ${result.surcharge} euros<br>"
              "Tax rate: $ratePercent %")
          .toJS;
      _content.appendChild(box);
    }
  }

  // --------------------------------------------------------------------
  // View [list of simulations]
  // --------------------------------------------------------------------
  void listView(List<Simulation> simulations, String? error, ListCallbacks callbacks) {
    _showMenu([
      _menuLink("Tax calculation", callbacks.onCalculation),
      _menuLink('End of session', callbacks.onEndSession),
    ]);

    _content.innerHTML = ''.toJS;

    final title = _div()
      ..className = 'section-title'
      ..textContent = 'List of your simulations';
    _content.appendChild(title);

    final banner = _errorBanner(error);
    if (banner != null) _content.appendChild(banner);

    if (simulations.isEmpty) {
      final empty = _div()
        ..className = 'simulations-empty'
        ..textContent = 'No simulation recorded.';
      _content.appendChild(empty);
      return;
    }

    final table = web.document.createElement('table') as web.HTMLTableElement;
    table.className = 'simulations';
    final thead = web.document.createElement('thead') as web.HTMLTableSectionElement;
    thead.innerHTML = ("<tr><th>#</th><th>Married</th><th>Number of children</th>"
            "<th>Annual salary</th><th>Tax amount</th><th>Surcharge</th>"
            "<th>Discount</th><th>Reduction</th><th>Rate</th><th></th></tr>")
        .toJS;
    table.appendChild(thead);

    final tbody = web.document.createElement('tbody') as web.HTMLTableSectionElement;
    for (var number = 0; number < simulations.length; number++) {
      final simulation = simulations[number];
      final tr = web.document.createElement('tr') as web.HTMLTableRowElement;
      final ratePercent = (simulation.rate * 100).round();
      tr.innerHTML = ("<td>$number</td>"
              "<td>${simulation.married}</td>"
              "<td>${simulation.children}</td>"
              "<td>${simulation.salary}</td>"
              "<td>${simulation.tax}</td>"
              "<td>${simulation.surcharge}</td>"
              "<td>${simulation.discount}</td>"
              "<td>${simulation.reduction}</td>"
              "<td>$ratePercent %</td>")
          .toJS;
      final tdDelete = web.document.createElement('td') as web.HTMLTableCellElement;
      final deleteLink = web.document.createElement('a') as web.HTMLAnchorElement;
      deleteLink.className = 'delete';
      deleteLink.textContent = 'Delete';
      deleteLink.addEventListener(
        'click',
        ((web.Event event) => callbacks.onDelete(number)).toJS,
      );
      tdDelete.appendChild(deleteLink);
      tr.appendChild(tdDelete);
      tbody.appendChild(tr);
    }
    table.appendChild(tbody);
    _content.appendChild(table);
  }
}

Analysieren wir diesen Code:

  • Zeile 19: [import 'package:web/web.dart' as web;]: der moderne Ersatz für das alte [dart:html], mit einer API und einem DOM, die dem von Views.ts verwendeten Standard-DOM sehr ähnlich sind ([document.createElement], [.textContent], [.addEventListener]...).
  • Zeilen 44–45: [typedef CalculationCallbacks = ({void Function(...) onSubmit, ...});]: Ein TypeScript-Callback-Interface lässt sich in Dart 3 ganz natürlich als RECORD VON FUNKTIONEN umsetzen — leichter als eine Klasse für eine einfache Gruppe von Funktionen.
  • Zeile 108: [a.addEventListener('click', ((web.Event event) { ... }).toJS);]: Ein Dart-Ereignishandler (eine einfache Funktion) muss mit [.toJS] (einer Erweiterung von [dart:js_interop]) in die JavaScript-Funktion umgewandelt werden, bevor er an [addEventListener] übergeben wird - die „Brücke“ zwischen der Dart-Welt und der JavaScript-Welt wird explizit gemacht, während TypeScript keine Konvertierung erfordert.
  • Zeile 141: [input.value = initialValue;], [title.textContent = '...';] (Zeile 76): Die meisten Eigenschaften vom Typ String bleiben einfache Dart-Strings, ohne dass eine Konvertierung nötig ist. [innerHTML] ist die AUSNAHME: [dart analyze] meldet dies, wenn ihm direkt ein [String] zugewiesen wird — sein Setter erwartet ein [JSAny] (eine Besonderheit seiner Generierung im Zusammenhang mit dem WebIDL-Attribut [LegacyNullToEmptyString] des Standard-DOM) — daher [root.innerHTML = ''.toJS;]: eine zusätzliche Konvertierung mit [.toJS], die über die Funktionen allein hinausgeht und die man bei jedem Umgang mit [innerHTML] im Kopf behalten muss.
  • Zeile 129: [(web.HTMLDivElement row, web.HTMLInputElement input) _fieldRow(...)]: ein positionaler RECORD als Rückgabetyp, um zwei DOM-Elemente auf einmal ohne Zwischenklasse zurückzugeben – eine weitere praktische Anwendung der Records von Dart 3.

6.5.7. Der Controller: die Datei [AppHtml.ts]

6.5.8. Skript [app_html]

// app_html.dart
// Portiert AppHtml.ts: der Controller der HTML-Anwendung. Er orchestriert die
// Aufrufe des Servers ([dao]-Schicht, dao3.dart), die Berechnungen
// ([business]-Schicht, business.dart) und die Anzeige der Views ([views]-Schicht,
// views.dart).
//
// Wie main3.dart ruft dieser Client den NestJS-Server nur für drei
// Aktionen auf: [init-session], [authenticate-user] und [get-admindata].
// Sobald die Steuerdaten (Sätze, Obergrenzen...) mit
// [get-admindata] geholt wurden, berechnet die [business]-Schicht die Steuer im
// Browser, ohne neuen Netzwerkaufruf. Die Liste der Simulationen wird ebenfalls
// nur im Browser gehalten (Feld [simulations]),
// genau wie main3.dart es mit seiner lokalen Variablen
// [simulations] tut (`simulations.add(...)`, `simulations.removeAt(...)`).
import 'dart:js_interop';
import 'package:http/browser_client.dart';
import 'dao3.dart';
import 'business.dart';
import 'simulation.dart';
import 'views.dart';
import 'package:web/web.dart' as web;

class AppHtml {
  final Dao3 dao;
  final Views views;
  // [business]-Schicht: existiert erst, wenn die Steuerdaten geholt wurden
  // (nach erfolgreicher Authentifizierung) - siehe [_initBusiness]. Ein
  // NULLBARES Feld (Business?), kein spätes Feld ([late]): Anders als in
  // Views.ts, wo [business?: Business] einfach "undefined" bleibt, solange
  // nichts zugewiesen wird, würde ein Dart-Feld [late] einen Fehler auslösen, wenn es
  // VOR der Zuweisung GELESEN würde (genau das tut [_endSession] beim
  // Zurücksetzen) - der nullbare Typ ist hier also die richtige Wahl, nicht
  // bloß eine Stilfrage.
  Business? _business;
  // Liste der bereits berechneten Simulationen, im Browser gehalten
  List<Simulation> _simulations = [];

  // [Unterschied zu TypeScript] AppHtml.ts konfiguriert eine GLOBALE axios-
  // Instanz (axios.defaults.timeout/baseURL/withCredentials) und übergibt sie dann
  // dem Dao. Hier trägt [BrowserClient] (package:http/browser_client.dart, bereits
  // in main3.dart begegnet) das Äquivalent zu
  // "axios.defaults.withCredentials = true"; ein direktes
  // Äquivalent eines "globalen Timeouts" gibt es bei http.Client nicht - er würde im Einzelfall
  // mit `.timeout(Duration(...))` bei jedem Aufruf angewendet, wie im Kapitel
  // zu [http] (dart_fetch_01.dart).
  AppHtml()
      : dao = Dao3(
          BrowserClient()..withCredentials = true,
          'http://localhost:3000',
        ),
        views = Views(web.document.getElementById('app') as web.HTMLElement);

  // Einstiegspunkt der Anwendung
  Future<void> start() async {
    try {
      // Sitzung initialisieren - zwingend vor jeder anderen Aktion (siehe main.php)
      final response = await dao.initSession() as Map<String, dynamic>;
      if (response['status'] != 700) {
        views.authenticationView(
          _formatError(response['response']),
          (onSubmit: (user, password) => _authenticate(user, password)),
        );
        return;
      }
    } catch (error) {
      views.authenticationView(
        "Unable to contact the server ($error)",
        (onSubmit: (user, password) => _authenticate(user, password)),
      );
      return;
    }
    // Sitzung initialisiert: wir zeigen die Authentifizierung an
    _showAuthentication();
  }

  // --------------------------------------------------------------------
  // View [authentication]
  // --------------------------------------------------------------------
  void _showAuthentication([String? error]) {
    views.authenticationView(
      error,
      (onSubmit: (user, password) => _authenticate(user, password)),
    );
  }

  Future<void> _authenticate(String user, String password) async {
    try {
      final response = await dao.authenticateUser(user, password)
          as Map<String, dynamic>;
      if (response['status'] == 200) {
        // erfolgreiche Authentifizierung: wie in main3.dart holen wir jetzt ein für alle Mal die
        // Steuerdaten,
        // die die [business]-Schicht benötigt
        await _initBusiness();
      } else {
        // Fehlschlag (falsches Login/Passwort oder fehlende Parameter)
        _showAuthentication(_formatError(response['response']));
      }
    } catch (error) {
      _showAuthentication("Unable to contact the server ($error)");
    }
  }

  // holt die Daten der Steuerverwaltung und instanziiert die
  // [business]-Schicht mit diesen Daten - ein einziger Serveraufruf für die ganze
  // Sitzung, genau wie in main3.dart
  Future<void> _initBusiness() async {
    try {
      final response = await dao.getAdminData() as Map<String, dynamic>;
      if (response['status'] == 1000) {
        _business = Business(response['response'] as Map<String, dynamic>);
        // neue Arbeitssitzung: wir beginnen wieder mit einer leeren Liste
        _simulations = [];
        _showCalculation();
      } else {
        _showAuthentication(_formatError(response['response']));
      }
    } catch (error) {
      _showAuthentication("Unable to contact the server ($error)");
    }
  }

  // --------------------------------------------------------------------
  // View [tax calculation]
  // --------------------------------------------------------------------
  void _showCalculation([Simulation? result, String? error]) {
    views.calculationView(
      result,
      error,
      (
        onSubmit: (married, children, salary) =>
            _calculate(married, children, salary),
        onList: () => _showList(),
        onEndSession: () => _endSession(),
      ),
    );
  }

  // Steuerberechnung vollständig im Browser ([business]-
  // Schicht): kein Aufruf des Servers, anders als in der ersten Version
  // dieses Clients (http client 1 / http client 2)
  void _calculate(String married, int children, int salary) {
    // _business wurde zwingend initialisiert: Wir gelangen erst nach _initBusiness zur View [calculation]
    // (das [!] ist hier also sicher, wie das [!] in TypeScript
    // bei [this.business!])
    final result = _business!.calculateTax(married, children, salary);
    // [Unterschied zu TypeScript] Views.ts baut die Simulation mit einem
    // einfachen Objekt-Spread: `{ married, children, salary, ...result }`.
    // Hier ist [Simulation] ein RECORD (simulation.dart), keine Map: Ein Record
    // lässt sich nicht durch Spreaden einer Map "ergänzen", und
    // seine Felder sind typisiert (num, int...), während
    // [result], von business.dart geliefert, eine untypisierte Map ist, deren Schlüssel
    // lediglich dieselben Namen HABEN ('tax', 'surcharge'..., siehe business.dart). Also
    // bauen wir den Record Feld für Feld neu auf - etwas ausführlicher
    // als ein Spread, aber vollständig vom Compiler geprüft (ein vergessenes
    // oder falsch typisiertes Feld ist ein Kompilierfehler, keine Überraschung zur
    // Laufzeit).
    final Simulation simulation = (
      married: married,
      children: children,
      salary: salary,
      tax: result['tax'] as num,
      surcharge: result['surcharge'] as num,
      discount: result['discount'] as num,
      reduction: result['reduction'] as num,
      rate: result['rate'] as num,
    );
    // Speicherung im Browser (wie `simulations.add(...)` in
    // main3.dart)
    _simulations.add(simulation);
    _showCalculation(simulation);
  }

  // --------------------------------------------------------------------
  // View [list of simulations]
  // --------------------------------------------------------------------
  // keine Serveraufrufe mehr hier: Die Liste liegt bereits vollständig in
  // [_simulations]
  void _showList([String? error]) {
    views.listView(
      _simulations,
      error,
      (
        onDelete: (number) => _deleteSimulation(number),
        onCalculation: () => _showCalculation(),
        onEndSession: () => _endSession(),
      ),
    );
  }

  void _deleteSimulation(int number) {
    // lokales Löschen aus [_simulations], wie
    // `simulations.removeAt(number)` in main3.dart - weiterhin kein
    // Serveraufruf
    _simulations.removeAt(number);
    _showList();
  }

  // --------------------------------------------------------------------
  // Ende der Sitzung
  // --------------------------------------------------------------------
  void _endSession() {
    // Ende der Sitzung nur auf Client-Seite: wir vergessen die [business]-Schicht
    // (und damit die Steuerdaten) und die bereits berechneten Simulationen, dann
    // kehren wir zum Authentifizierungsbildschirm zurück. Dieser Client muss dafür den Server nicht
    // aufrufen.
    _business = null;
    _simulations = [];
    _showAuthentication();
  }

  // --------------------------------------------------------------------
  // formatiert das Feld [response] einer Fehlerantwort des Servers, das
  // entweder ein String oder eine Liste von Strings ist (siehe PHP-Controller)
  // --------------------------------------------------------------------
  String _formatError(Object? response) {
    if (response is List) {
      return response.join(' ; ');
    }
    return '$response';
  }
}

// Ausführung - [Unterschied zu TypeScript] der an addEventListener übergebene Ereignishandler
// muss mit
// [.toJS] in eine JavaScript-Funktion umgewandelt werden (siehe views.dart); das ist nur die Version
// derselben Regel für den "Einstiegspunkt".
void main() {
  web.window.addEventListener(
    'DOMContentLoaded',
    ((web.Event event) {
      AppHtml().start();
    }).toJS,
  );
}

Kommentieren wir diesen Code:

  • Zeilen 46–51: [AppHtml() : dao = Dao3(BrowserClient()..withCredentials = true, ...), views = Views(...)]: Konstruktion des DAO und der VIEWS in einer INITIALISIERUNGSLISTE – dasselbe Konzept wie der TypeScript-Konstruktor, aber mit der Dart-spezifischen Syntax [: field1 = ..., field2 = ...].
  • Zeile 34: [Business? _business;]: ein NULLABLE-Feld, wo AppHtml.ts zuvor [business?: Business] verwendete – dasselbe Konzept („noch nicht initialisiert“), mit demselben Operator [!], um zu bestätigen, dass das Feld an einer bestimmten Stelle im Code tatsächlich gefüllt ist.
  • Zeilen 158–162: [final Simulation simulation = (married: married, ..., tax: result['tax'] as num, ...);]: anders als der einfache Spread [{ married, children, salary, ...result }] in AppHtml.ts lässt sich ein RECORD nicht per Spread aus einer [Map] vervollständigen – der Record wird daher FELD FÜR FELD neu aufgebaut, was etwas ausführlicher, aber vollständig vom Compiler geprüft ist.
  • Zeilen 229–233: [web.window.addEventListener('DOMContentLoaded', ((web.Event event) { AppHtml().start(); }).toJS);]: derselbe Einstiegspunkt wie in AppHtml.ts, mit derselben Callback-Konvertierung ([.toJS]) wie in views.dart.

6.5.9. Kompilierung und Ausführung

Siehe README.md in diesem Ordner: [dart pub get], gefolgt von [webdev serve] für die Entwicklung (einschließlich Hot Reloading), oder [dart compile js web/main.dart -o web/main.dart.js] für einen Produktions-Build – das Dart-Äquivalent zu [npm run build], ohne vorherige Konfigurationsschritte für einen Bundler.

Läuft der Server [webdev serve] für die Webanwendung [http client 3] noch, müssen Sie ihn beenden (Strg-C im Terminal, in dem er gestartet wurde). Öffnen Sie dann in einem Terminal im Verzeichnis [html client]:

dart pub get
webdev serve

Zeile 2 startet den Webserver, der die HTML-Client-Anwendung bereitstellt:

Image

  • In [1] rufen Sie in einem Browser die URL [http://localhost:8080] auf;
  • in [2-3] geben Sie die Zugangsdaten admin / admin ein;
  • In [4] senden Sie die Seite ab;

Image

  • In [2] füllen Sie die Felder aus;
  • In [3] senden Sie die Seite ab;

Image

Der Steuerbetrag wird in [1] angezeigt. Führen Sie mehrere Simulationen durch und rufen Sie dann in [2] die Liste ab;

Image

  • In [1] löschen Sie eine Simulation;

Image

  • in [1] beenden Sie die Sitzung;

Image

6.6. Fazit

Die vier Clients dieses Kapitels veranschaulichen mit Dart exakt dieselbe Entwicklung wie mit TypeScript: von der serverseitigen Verarbeitung zur clientseitigen Verarbeitung, dann vom CLI-Skript zum vollständigen Web-Client. Die wichtigsten Unterschiede sind die manuelle Verwaltung des Sitzungs-Cookies (in der CLI notwendig, im Browser überflüssig), die von [dart:js_interop] erzwungene Konvertierung [.toJS], um in den Views die Grenze zwischen Dart und JavaScript zu überbrücken, und das völlige Fehlen von Polyfills bei der Webkompilierung – ein klarer Vorteil der Dart-Toolchain gegenüber der webpack/babel-Pipeline.